Runbeam Now Speaks MCP: Manage Your Gateway Infrastructure with AI Agents

Infrastructure management is shifting. AI coding agents are moving beyond code generation into operational tasks—provisioning resources, configuring services, and managing deployments through natural language. But these agents need structured interfaces to interact with the systems they manage.

Runbeam now exposes a native MCP server, giving AI agents direct, authenticated access to manage Harmony API gateway configurations. With 52 tools across 11 resource categories, agents can handle the full lifecycle of gateway management—from creating pipelines and configuring endpoints to generating TOML configurations and reviewing pending changes.

What Is MCP?

Model Context Protocol (MCP) is an open standard that defines how AI agents discover and invoke external tools. Instead of writing custom integrations for each AI platform, you expose a single MCP server that any compatible agent can connect to.

MCP uses JSON-RPC 2.0 over HTTP, making it straightforward to implement and debug. Agents send structured tool calls, receive structured responses, and can chain multiple operations together to accomplish complex tasks.

What You Can Do

The MCP server covers the full Harmony resource model. AI agents can manage gateways, pipelines, endpoints, backends, middleware, transforms, services, networks, policies, and cross-team endpoint sharing—all through structured tool calls.

Gateway Management

Create and inspect Harmony gateway instances. List all gateways belonging to your team, retrieve detailed configuration for a specific gateway, create new instances with custom logging and polling settings, and generate complete TOML configurations for deployment review.

Pipeline Configuration

Build complete traffic flow definitions. Create pipelines that connect endpoints to backends through middleware chains, attach and detach ingress and egress points, and import or export pipeline configurations as TOML. Agents can walk through the full pipeline construction process step by step.

Protocol and Transform Operations

Define services for protocols like HTTP, DICOM, FHIR, DICOMweb, and others. Create JOLT transformation rules that reshape data between schemas declaratively. Agents can build and modify transforms interactively, testing different mapping strategies without touching application code.

Security and Policy

Inspect policies and their associated rules. Review configuration issues across gateways and pipelines. Manage authentication configurations for endpoints and backends.

Cross-Team Sharing

Publish endpoints for other teams to discover, manage incoming access requests with approval and rejection workflows, and monitor subscriptions to shared endpoints. This enables AI-assisted governance of cross-organisation data exchange.

Connecting Your AI Agent

The MCP server authenticates via API tokens, and all operations are automatically scoped to the authenticated user's current team. This means agents can only access and modify resources belonging to your team—there is no cross-team access.

Claude Code

Add the Runbeam MCP server to your project's .mcp.json:

{
  "mcpServers": {
    "runbeam": {
      "type": "url",
      "url": "https://app.runbeam.io/mcp/runbeam",
      "headers": {
        "Authorization": "Bearer your-token"
      }
    }
  }
}

Or via the CLI:

claude mcp add runbeam \
  --transport http \
  --url https://app.runbeam.io/mcp/runbeam \
  --header "Authorization: Bearer your-token"

Cursor

Add to .cursor/mcp.json:

{
  "mcpServers": {
    "runbeam": {
      "url": "https://app.runbeam.io/mcp/runbeam",
      "headers": {
        "Authorization": "Bearer your-token"
      }
    }
  }
}

OpenAI Codex

Add to your project's codex.json:

{
  "mcpServers": {
    "runbeam": {
      "type": "url",
      "url": "https://app.runbeam.io/mcp/runbeam",
      "headers": {
        "Authorization": "Bearer your-token"
      }
    }
  }
}

Any MCP Client

The server expects Streamable HTTP (POST) requests to https://app.runbeam.io/mcp/runbeam with an Authorization: Bearer {token} header and application/json content type. Any MCP-compatible client can connect.

Example: Building a Pipeline with an AI Agent

Here is what a typical interaction looks like when an AI agent builds a complete pipeline through the MCP server.

The agent starts by understanding the current state:

1. get-team-context — retrieves resource counts and team overview
2. list-gateways — finds existing gateway instances
3. list-services — discovers available protocol types

Then it builds the pipeline components:

4. create-endpoint — defines an ingress point with connection details and service type
5. create-backend — defines an egress point with target connection, timeout, and retry settings
6. create-transform — writes JOLT transformation rules for request/response mapping
7. create-pipeline — creates the pipeline on the target gateway

Next, it wires everything together:

8. attach-pipeline-endpoints — connects the ingress point to the pipeline
9. attach-pipeline-backends — connects the egress point to the pipeline
10. create-middleware — adds processing steps (transforms, authentication, policies)

Finally, it validates the result:

11. generate-pipeline-toml — produces the complete Harmony TOML configuration for review
12. list-configuration-issues — checks for any problems in the configuration

This entire workflow happens through natural language. You describe what you need—"create a pipeline that accepts FHIR requests and routes them to our internal API with bearer token auth"—and the agent translates that into the correct sequence of MCP tool calls.

Smoother infrastructure configuration

Infrastructure-as-code has improved how teams manage gateway configurations, but it still requires writing and maintaining configuration files, understanding TOML syntax and Harmony's resource model, and manual review cycles for changes.

MCP-based management adds a conversational layer on top. Engineers can describe intent rather than writing configuration directly. The agent handles resource creation, relationship wiring, and validation—while the engineer reviews the generated TOML before deployment.

This is particularly valuable in regulated environments where gateway configurations control how data flows across trust boundaries. The MCP server provides:

Audit trails — every tool call is authenticated and rate-limited through the API middleware, creating a record of who made what changes and when.

Team scoping — all operations are automatically restricted to the authenticated user's team, preventing accidental cross-team modifications.

Read-before-write workflows — agents can inspect existing configurations, list issues, and generate TOML for review before making destructive changes. Six tools are explicitly marked as destructive, requiring deliberate invocation.

Configuration validation — the list-configuration-issues tool surfaces problems across gateways, pipelines, endpoints, and backends, catching misconfigurations before deployment.

Getting Started

1. Generate a token from the Runbeam UI under your team settings.

2. Add the MCP server to your AI coding tool using one of the configurations above.

3. Start with read-only operations — ask your agent to describe your current gateway setup, list pipelines, or check for configuration issues.

4. Build a pipeline — describe what you need in natural language and let the agent construct the configuration through tool calls.

5. Review the output — use generate-gateway-toml or generate-pipeline-toml to inspect the generated configuration before deploying.

Learn More

• Model Context Protocol Specification
• Connecting AI to Any API
• Harmony Documentation

Infrastructure management is becoming conversational. Give your AI agent access to your Harmony gateways—securely, with full audit trails, and scoped to your team.