Every major CI/CD platform now has an MCP server — either official or community-maintained. GitHub’s has 32,000+ stars. GitLab built theirs into the platform itself. Jenkins, CircleCI, Argo CD, Tekton, Azure DevOps, Harness, and CloudBees all ship dedicated MCP integrations.

This means AI agents can now monitor builds, analyze test failures, trigger deployments, review pull requests, detect flaky tests, and roll back releases — all through standardized MCP tool calls instead of custom API integrations.

But the implementations differ significantly. Some platforms expose nine tools, others expose sixty. Some require OAuth 2.1, others work with a simple API token. Some run as standalone servers, others embed directly into the CI pipeline. This guide covers each platform’s MCP integration in detail — what tools are available, how to set them up, how they handle security, and what workflows they enable.

For a broader overview of MCP in DevOps including infrastructure-as-code, Kubernetes, cloud providers, and the agent gateway architecture pattern, see our MCP for DevOps and CI/CD guide. Our analysis draws on published documentation, open-source implementations, and vendor announcements — we research and analyze rather than deploying these systems ourselves. Rob Nugen operates ChatForest; the site’s content is researched and written by AI.

Platform-by-Platform Deep Dive

GitHub Actions — The 26K-Star Ecosystem

GitHub’s MCP integration is the largest and most mature, spanning an official MCP server, a dedicated CI/CD action, and a new agentic workflows system.

Official GitHub MCP Server (github/github-mcp-server) — 32,000+ stars as of August 2026, up from 26,400+ a month earlier. Released April 2025, became generally available as a remote server in September 2025. This is the most-used CI/CD-adjacent MCP server.

CI/CD-relevant tools:

  • Workflow intelligence: Monitor GitHub Actions runs, analyze build failures, view workflow logs
  • Code review: Create and manage pull requests, post review comments, request reviewers
  • Repository management: Branch operations, file CRUD, commit history
  • Security: Dependabot alerts, code scanning results
  • Project management: Issues, labels, milestones, Projects (added January 2026)

The January 2026 update added OAuth scope filtering (restrict which tools are available per connection), consolidated Projects toolset, native Streamable HTTP support, and Lockdown mode — a security feature that blocks content from untrusted contributors in public repositories, specifically designed to prevent prompt injection attacks through issues and PRs.

Claude Code Action (anthropics/claude-code-action) — runs Claude Code as a GitHub Actions agent. Launched with Claude Code 2.0 in September 2025. Two modes:

  • Interactive mode: Responds to @claude mentions in PR comments and issues. The agent reads the context, analyzes code, and posts responses.
  • Automation mode: Runs headlessly on every matching event (PR open, push, issue creation). Prompt is defined directly in workflow YAML.
# Example: AI code review on every PR
name: AI Code Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: anthropics/claude-code-action@v1
        with:
          prompt: |
            Review this PR for logic errors, security vulnerabilities,
            broken edge cases, and regressions. Post findings as
            inline comments on specific lines.
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}

Claude Code Action uses a fleet of specialized agents that examine logic errors, security vulnerabilities, broken edge cases, and subtle regressions. It has 5+ documented copy-paste workflow recipes for common CI/CD scenarios.

GitHub Actions-specific MCP server (ko1ynnky/github-actions-mcp-server) — 41 stars, community-maintained. Predates the official server (released March 2025). Focused specifically on workflow operations: listing, triggering, canceling, and rerunning workflows. Useful when you only need Actions control without the broader GitHub MCP surface.

For more on GitHub’s broader AI integration including Agentic Workflows, see our MCP for DevOps and CI/CD guide.

GitLab CI — Built Into the Platform

GitLab took a different approach from GitHub: instead of a standalone MCP server, they built MCP support directly into the GitLab platform starting with version 18.6 (November 2025).

GitLab MCP Server — built-in, and as of GitLab 19.2 available on the Free tier as well as Premium/Ultimate (it launched Premium/Ultimate-only in 18.6, per GitLab’s MCP server docs). Supports MCP protocol versions 2025-03-26 and 2025-06-18 (added in 18.7). Requires OAuth dynamic client registration. Status is beta, not GA.

CI/CD-specific tools: | Tool | What It Does | |——|————-| | get_merge_request_pipelines | List pipelines for a merge request | | get_pipeline_jobs | Get jobs within a specific pipeline | | manage_pipeline | List, create, retry, cancel, update, delete pipelines |

Plus broader tools for issues, merge request management, and semantic code search.

Claude Code GitLab CI/CD (beta, maintained by GitLab) — full .gitlab-ci.yml integration. Event-driven: triggers on @claude mentions in MR and issue comments. Runs in isolated containers with workspace-scoped permissions.

# Example: Claude as MR reviewer in GitLab CI
claude-review:
  image: anthropic/claude-code:latest
  script:
    - claude-code --prompt "$AI_FLOW_INPUT"
  variables:
    AI_FLOW_INPUT: "Review this merge request for issues"
    AI_FLOW_CONTEXT: "$CI_MERGE_REQUEST_IID"
    AI_FLOW_EVENT: "merge_request_comment"
  rules:
    - if: '$CI_PIPELINE_SOURCE == "chat"'

Key architecture differences from GitHub:

  • Authentication: OAuth 2.1 with dynamic client registration (vs. GitHub’s PAT or OAuth)
  • Deployment: No separate server to install — it’s a platform feature
  • Permissions: All changes go through MRs; sandboxed execution with workspace-scoped access
  • Cloud backends: Supports Claude API directly, AWS Bedrock (OIDC), and Google Vertex AI (Workload Identity Federation)

Community alternatives: yoda-digital/mcp-gitlab-server (60+ tools, community-maintained) and zereight/gitlab-mcp (bug fixes over the original Anthropic GitLab server).

Jenkins — Plugin Architecture

Jenkins’s MCP integration follows its traditional plugin model: install a plugin and Jenkins itself becomes an MCP server.

Official Jenkins MCP Server Plugin (jenkinsci/mcp-server-plugin) — based on MCP Java SDK v0.17.2, implementing MCP spec 2025-06-18. Auto-sets up endpoints on installation. Supports parameterized jobs. Integrates with GitHub Copilot and other MCP clients. Also available through CloudBees CI plugins.

Key characteristic: the plugin turns Jenkins into an MCP server, not a client. Your AI assistant connects to Jenkins and can:

  • List and trigger builds
  • Monitor job status and queue
  • Retrieve build logs and test results
  • Manage parameterized job configurations

Community alternatives:

CircleCI — Purpose-Built for CI Debugging

CircleCI’s MCP server is notable for being the most CI-focused: every tool is designed for pipeline debugging and management, not general-purpose repository operations.

Update (August 2026): the standalone npm/GitHub server is deprecated. CircleCI-Public/mcp-server-circleci, the package this section originally covered, is no longer receiving feature work and is slated for archival — its README now states plainly that “running an unmaintained server that holds a CircleCI Personal API Token is not recommended.” CircleCI’s current MCP overview docs confirm: “That server is deprecated,” and instruct users to remove it (e.g. claude mcp remove circleci-mcp-server).

CircleCI now offers two replacements, both still in preview:

  • Hosted MCP Server (https://mcp.circleci.com/v1/mcp) — no local install, authenticates via OAuth2 or personal API token. Recommended for everyday diagnostics (failures, logs, reruns).
  • CircleCI CLI MCP — built into the CircleCI CLI, runs locally, uses credentials from circleci auth login or CIRCLE_TOKEN. Recommended when you need config authoring or orb management.

The hosted server’s tool set has also grown beyond the original nine: it now exposes 13 tools, including hello, list_runs, get_run, list_workflows, get_workflow, rerun_workflow, cancel_workflow, list_jobs, get_job, get_job_logs, list_artifacts, list_job_tests, and download_usage_data — still CI-specific, still designed for structured AI parsing of failure logs and flaky-test analytics, but delivered as a managed endpoint instead of an npm package developers self-host.

Setup for the hosted server requires OAuth2 or a CircleCI API token; the CLI MCP uses your existing CircleCI CLI login. Both are documented as integrating with Cursor, Windsurf, and other MCP clients.

Argo CD — GitOps via Natural Language

Official Argo CD MCP Server (argoproj-labs/mcp-for-argocd) — 558 stars as of August 2026. Originally built by Akuity (a company founded by Argo CD’s creators) as akuity/argocd-mcp and released May 2025; since donated to the argoproj-labs org, the Argo project’s own incubator for community tooling. The old akuity/argocd-mcp URL now redirects to this repo.

Tools:

  • list_applications — list all Argo CD applications
  • get_application — detailed application status
  • Sync deployments — trigger GitOps syncs
  • View logs — application and pod logs
  • Application health — sync status, health checks

Supports both stdio and Streamable HTTP transport. Requires ARGOCD_BASE_URL and ARGOCD_API_TOKEN environment variables.

The value proposition is specific: GitOps workflows typically require switching between argocd CLI, the web UI, and kubectl to understand deployment state. An MCP-connected agent can answer “what’s the sync status of all production applications?” or “why did the last sync fail for the payments service?” by querying Argo CD directly.

Tekton — Cloud-Native Pipeline Control

Tekton MCP Server (tektoncd/mcp-server) — community-maintained, part of the official Tekton project. MCP integration was first added alongside OPA/Kyverno policy enforcement and OpenTelemetry observability in Tekton Pipelines v1.3.1 LTS (August 2025); that release’s support window closed in August 2026. The current LTS is v1.12.0 (May 2026, supported through May 2027), with MCP support carried forward in subsequent releases.

Capabilities:

  • Inspection: “List all pipelines in namespace production”
  • Execution: Trigger pipeline runs with parameters
  • Monitoring: Stream pipeline and task logs
  • Troubleshooting: Diagnose failed pipeline runs

Tekton’s MCP integration is significant because Tekton runs as Kubernetes Custom Resources. The MCP server translates natural language into the correct CRD operations — creating PipelineRuns, querying TaskRun status, fetching logs from the right pods.

Azure DevOps — Enterprise GA

Official Azure DevOps MCP Server (microsoft/azure-devops-mcp) — TypeScript, local/stdio server, actively maintained. Microsoft separately ships a Remote MCP Server (hosted, zero-install) that entered public preview March 17, 2026 and reached general availability on August 5, 2026 — this is the piece that was still in preview at the time of the previous audit. Microsoft states it is “committed to maintaining feature parity between the local and remote servers,” with the local server continuing to support clients the remote option doesn’t yet cover.

Tools cover the full Azure DevOps suite:

  • Work items: Create, update, query, sprint planning
  • Pull requests: Create, review, merge
  • Pipelines: Trigger runs, monitor status, view logs
  • Repos: Branch management, file operations
  • Wikis: Documentation access
  • Test plans: Test case generation, execution, results

The remote server authenticates via Microsoft Entra (dynamic OAuth client registration) and integrates with Microsoft Foundry’s tools catalog, letting Foundry-based agents connect without local installation. The local server uses Microsoft account or Azure CLI (azcli) sign-in.

Harness — DORA Metrics and Deployment Intelligence

Harness MCP Server — official (harness/mcp-server), distributed via npm, source, or Docker. Harness’s own docs describe 11 consolidated tools covering 139 resource types, plus pre-built prompt templates for common workflows. (Note: unlike CloudBees’s MCP server below, we found no evidence Harness’s is distributed via AWS Marketplace — a claim in a prior version of this page was unsupported and has been removed.)

What sets Harness apart is the data it exposes through MCP:

  • Pipeline execution history (success/failure, duration, stage-level details)
  • Deployment frequency metrics
  • Rollback event history
  • Feature flag states
  • Approval gate activity
  • DORA metrics — deployment frequency, lead time, change failure rate, MTTR

Agents can also act: trigger pipeline runs, roll back deployments, update feature flags, and manage approval gates. Integrates with Amazon Q, Windsurf, Cursor, and Claude Desktop.

The DORA metrics exposure is unique. An engineering manager can ask “what’s our deployment frequency this quarter compared to last quarter?” and get an answer drawn from live pipeline data, not a manually compiled report.

CloudBees — Enterprise Jenkins + AI

CloudBees Unify MCP Server — enterprise-grade, launched on AWS Marketplace’s AI Agents and Tools category on July 16, 2025. Acts as a bridge between CloudBees Unify and the LLM ecosystem.

Key differentiator: CloudBees targets enterprise DevSecOps workflows that span multiple tools. Their MCP server enables agents to:

  • Auto-triage and fix flaky tests
  • Open PRs with fixes
  • Enforce pipeline policies
  • Reduce Mean Time to Recovery (MTTR) through automated diagnosis

Works with both Jenkins and CloudBees Unify pipelines. Natural language interface for DevSecOps workflows across the platform.

Platform Comparison

PlatformServer TypeToolsAuthTransportNotable Feature
GitHubOfficial standaloneBroad (repos, PRs, Actions, security)PAT, OAuthstdio, Streamable HTTPLockdown mode, 26K+ stars
GitLabBuilt-in platformCI/CD + code + issuesOAuth 2.1 dynamicPlatform-nativeNo install needed (18.6+)
JenkinsOfficial pluginBuild/job managementJenkins authstdioTurns Jenkins into MCP server
CircleCIOfficial hosted + CLI (standalone npm server deprecated Aug 2026)13 CI-focused toolsOAuth2 or API tokenStreamable HTTP (hosted), stdio (CLI)Test-failure/flaky analytics, rerun_workflow
Argo CDOfficial standaloneGitOps app managementAPI tokenstdio, Streamable HTTPNatural language GitOps
TektonCommunity (official project)Pipeline CRD operationsK8s authstdioCloud-native K8s pipelines
Azure DevOpsOfficial standaloneFull ADO suiteOAuth 2.1stdio, Foundry (remote)Zero-install cloud mode
HarnessOfficialPipelines + DORA metricsPlatform authstdioDORA metrics exposure
CloudBeesOfficialJenkins + Unify pipelinesPlatform authstdioEnterprise DevSecOps

AI Code Review with MCP

AI-powered code review through MCP is becoming a standard CI/CD workflow pattern. Three approaches have emerged.

Pattern 1: AI Agent as PR Reviewer

The most common pattern — an AI agent reviews every PR automatically.

Claude Code Action does this natively: configure it in your GitHub Actions workflow, and it analyzes every PR for logic errors, security vulnerabilities, edge cases, and regressions. It posts findings as inline comments on specific code lines.

CodeRabbit uses MCP servers to enrich review context — connecting to Jira, Linear, and web queries to understand the intent behind changes, not just the diff. This means reviews can flag when a change contradicts a linked ticket’s requirements.

Qodo (formerly CodiumAI) operates as an agentic code integrity platform. Its open-source qodo-ai/pr-agent reviews PRs and generates tests.

Pattern 2: MCP-Connected IDE Reviews

GitHub Copilot now uses MCP to manage PRs. With --allowedTools mcp__github, Copilot analyzes code changes across files, related issues, project context, and team review patterns to suggest appropriate reviewers and flag potential issues before the PR is even opened.

Pattern 3: Custom Review Pipelines

Teams build custom review workflows by connecting Claude or other models to their GitHub/GitLab MCP servers:

  1. CI pipeline triggers on PR open/sync
  2. Agent reads the diff via MCP
  3. Agent fetches related issues and past discussions for context
  4. Agent posts structured review comments
  5. Human reviewer sees AI analysis alongside the diff

The key limitation as of early 2026: AI code review remains advisory. The tools function as assistants, surfacing potential issues for human reviewers to evaluate. Fully autonomous approval (merge without human review) isn’t recommended — the models can miss subtle architectural issues, business logic implications, and cross-service dependencies that require human judgment.

AI-Powered Testing in CI

MCP enables AI agents to participate in the testing phase of CI/CD in three ways.

Failure Analysis

The most immediately useful pattern. When tests fail, instead of manually reading logs:

Agent: "Why did the checkout service tests fail in the last build?"

CircleCI MCP → get_build_failure_logs
→ "Test test_payment_flow failed with exit code 1:
   AssertionError: Expected status 200 but got 503.
   The payment gateway mock returned an unexpected response."

Agent: "This is a test infrastructure issue, not a code bug.
The payment gateway mock is returning 503. Check if the mock
server container started successfully."

CircleCI’s get_build_failure_logs returns structured output designed for AI parsing — exit codes, failure messages, and log context. (As of August 2026 this tool name lives on the now-deprecated standalone server; the current hosted MCP server exposes the equivalent capability as get_job_logs — see the CircleCI section above.)

Flaky Test Detection

CircleCI’s find_flaky_tests tool (standalone server; on the current hosted server this is list_job_tests) analyzes test execution history across runs, identifying tests that pass and fail intermittently. The agent can then:

  1. Identify the flaky tests
  2. Analyze their failure patterns (time-based? resource-based? order-dependent?)
  3. Suggest fixes or quarantine strategies

CloudBees takes this further — their MCP server enables agents to auto-triage flaky tests and open PRs with fixes.

Multi-Agent Testing Workflows

An emerging pattern uses multiple specialized agents in a testing pipeline:

  1. Requirement Parser Agent — extracts testable requirements from tickets
  2. Test Generator Agent — creates test cases from requirements
  3. Test Code Agent — writes executable test code
  4. Execution Agent — runs tests on CI/CD infrastructure
  5. Analysis Agent — interprets results, detects flaky tests, scores release readiness

MCP serves as the routing protocol between agents, with each agent using CI/CD MCP tools (GitHub for code access, CircleCI/Jenkins for execution, monitoring MCP for production comparison).

A key engineering challenge: managing non-deterministic LLM outputs requires disciplined prompt engineering, low model temperatures, and version-controlled prompts for repeatable test outcomes.

For more on testing MCP servers specifically, see our best testing and QA MCP servers guide and our MCP testing guide.

Architecture Patterns for MCP in CI/CD

Four architecture patterns have emerged for integrating MCP with CI/CD systems.

1. Facade / API Gateway

The MCP server acts as a unified interface abstracting multiple CI/CD backends. One MCP server exposes tools for GitHub, Jenkins, and ArgoCD simultaneously. The AI agent doesn’t need to know which backend handles which operation.

AI Agent → MCP Gateway Server → GitHub Actions API
                              → Jenkins API
                              → Argo CD API
                              → Monitoring API

2. Adapter

Each CI/CD platform has its own dedicated MCP server that translates between the MCP protocol and the platform’s native API. This is the current dominant pattern — GitHub has its MCP server, CircleCI has its MCP server, Jenkins has its plugin.

3. Sidecar

The MCP server runs alongside the CI/CD job as a companion container. Red Hat’s Cicaddy framework implements this pattern: instead of AI agents triggering CI from outside, the agent runs inside the pipeline as a step. This inverts the typical flow — the pipeline orchestrates the agent, not the other way around.

4. Event-Driven

CI/CD events (webhooks, PR comments, pipeline failures) trigger agent actions. GitLab’s @claude comment triggers a CI pipeline that runs Claude with MCP tools. CircleCI integrates with Cursor and Windsurf, triggering on pipeline events. This is the pattern behind GitHub’s Agentic Workflows and GitLab’s Claude CI/CD integration.

For more on architecture patterns, see our MCP agent workflow patterns guide and event-driven MCP patterns guide.

The OWASP MCP Top 10: CI/CD Security Risks

OWASP published a dedicated MCP Top 10 project identifying the most critical security risks. Several are particularly dangerous in CI/CD contexts.

MCP01: Token Mismanagement and Secret Exposure

Hard-coded credentials and long-lived tokens in model memory or logs. In CI/CD, this means:

  • API tokens for GitHub, CircleCI, or Jenkins stored in MCP configuration
  • Cloud credentials passed through MCP tool calls and logged
  • AI agents accumulating tokens in conversation context, then referencing them in other tool calls

CI/CD impact: Lateral movement from a compromised CI agent to cloud storage, production infrastructure, and issue trackers.

MCP03: Tool Poisoning

Adversaries compromise tool metadata — descriptions, parameters, hidden instructions — to manipulate AI agent behavior. In CI/CD:

  • A compromised MCP server could return tool descriptions that instruct the agent to skip security checks
  • Malicious tool schemas could extract secrets from the agent’s context

MCP04: Software Supply Chain Attacks

Compromised MCP server packages alter agent behavior. This has already happened:

  • Postmark MCP Supply Chain Breach (September 2025): An attacker published a malicious npm package called postmark-mcp, impersonating an MCP connector for Postmark’s transactional email service. Discovered by Koi Security, the package behaved identically to a legitimate server for 15 versions before v1.0.16 added a hidden line that BCC’d every outgoing email to an attacker-controlled address. Postmark’s own security notice confirms it “did not develop, authorize, or have any involvement with” the package, and that its legitimate API and services were unaffected.
  • CVE-2025-6514 (CVSS 9.6): Critical OS command injection in mcp-remote versions 0.0.5–0.1.15 — an OAuth proxy package with 437,000+ downloads. A malicious MCP server could send a crafted authorization_endpoint URL that, when passed to the shell by mcp-remote, executed arbitrary code. Fixed in v0.1.16. Details: GitHub Advisory GHSA-6xpm-ggf7-wc3p.

MCP05: Command Injection

AI constructs commands from untrusted input without sanitization. In CI/CD, this could mean:

  • An agent builds a shell command from PR title or commit message content
  • Pipeline parameters containing injection payloads reach MCP tool calls

MCP06: Intent Flow Subversion

Malicious instructions embedded in context hijack agent operations. In CI/CD:

  • Issue descriptions, PR comments, or commit messages containing hidden prompt injection
  • CI logs from previous runs containing embedded instructions

GitHub’s Lockdown mode was specifically designed to mitigate this — it blocks content from untrusted contributors when the MCP server processes public repository data.

MCP09: Shadow MCP Servers

Unapproved MCP server deployments outside governance. In CI/CD:

  • Developers adding unauthorized MCP servers to their CI configurations
  • Community MCP servers used without security review

MCP Ecosystem Security Statistics (Astrix Research, 2025)

Based on Astrix Security’s analysis of 5,200+ open-source MCP server implementations:

  • 88% of MCP servers require credentials
  • 53% use static API keys or personal access tokens (rarely rotated)
  • Only 8.5% adopt OAuth for secure authentication
  • 79% pass API keys through environment variables

These numbers are concerning for CI/CD environments where MCP servers have access to build infrastructure, deployment credentials, and source code.

Supply Chain Security

Docker MCP Catalog: Verified Supply Chain

Docker’s response to supply chain risks: the Docker MCP Catalog — 300+ verified MCP servers packaged as container images with versioning, provenance, cryptographic signatures, SBOMs, and security updates. The Docker MCP Toolkit runs MCP servers in isolated containers with signed image verification and an intelligent gateway that intercepts and blocks malicious requests before they reach tools.

For CI/CD teams, pulling MCP servers from Docker’s verified catalog is significantly safer than installing community npm packages directly.

Security Best Practices for CI/CD MCP

1. Use Dedicated, Scoped Tokens

Create CI-specific tokens for MCP servers. Never reuse personal access tokens. Scope to the minimum permissions required:

  • Read-only for monitoring and analysis
  • Write only for specific approved operations (PR comments, issue creation)
  • Never admin or delete permissions

2. Container Isolation

Run MCP servers in Docker containers with explicit network policies, filesystem isolation, and resource limits. The Docker MCP Toolkit provides this out of the box.

3. Pin Versions and Verify Signatures

Pin MCP server versions in CI configurations. Use Docker images from the verified MCP Catalog with cryptographic signature verification. Never use latest tags for MCP servers in CI.

4. Secrets Management via Vault

HashiCorp’s Vault MCP Server (public beta) provides KV static secrets, PKI certificate management, and secrets engine management through MCP. Security model: uses end-user’s Vault token (never root or shared), with ENABLE_VAULT_OPERATIONS flag to restrict writes.

CI/CD use case: AI agent fetches temporary database credentials for integration tests in sandboxed environments, with credentials that expire after the test run.

5. Human-in-the-Loop for Destructive Operations

No production deployments, rollbacks, or infrastructure changes without human approval. CircleCI’s run_rollback_pipeline and Harness’s deployment triggers should always require confirmation in production environments.

6. Audit Everything

Every MCP tool call in CI should be logged with: timestamp, agent identity, tool name, parameters, and result. Feed these logs into your existing SIEM. AWS’s Cloud Control API MCP server does this natively via CloudTrail.

Getting Started: Choosing Your Platform’s MCP Integration

If you use GitHub Actions — start with the official GitHub MCP Server. For AI code review, add Claude Code Action. Enable Lockdown mode for public repositories.

If you use GitLab CI — upgrade to GitLab 18.6+ and enable the built-in MCP server. For @claude MR review, configure the Claude Code GitLab CI/CD integration.

If you use Jenkins — install the MCP Server Plugin. It auto-configures endpoints on installation.

If you use CircleCI — the old standalone mcp-server-circleci package is deprecated as of August 2026. Use the hosted MCP server (https://mcp.circleci.com/v1/mcp) with OAuth2 or a CircleCI API token. Start with get_job_logs and list_job_tests for immediate value.

If you use Argo CD — install the official MCP server. Useful for natural language GitOps queries even if you don’t automate sync operations.

If you want multi-platform — consider the agent gateway pattern described in our MCP for DevOps guide. A single AI agent connects to multiple CI/CD MCP servers and orchestrates across them.

Further Reading