# Deploy Workflows as MCP

Expose your workflows as MCP tools for external AI assistants and applications

Deploy your workflows as MCP tools to make them accessible to external AI assistants like Claude Desktop, Cursor, and other MCP-compatible clients. This turns your workflows into callable tools that can be invoked from anywhere.

Workflow MCP servers expose your deployed workflows as tools. A server is either **Public** or **Private**. Anyone with the URL can call a public server. Callers of a private server sign in with OAuth or send a Workspace, Personal, or Organization API key. To drive SteelEngine itself — building and managing workflows from an MCP client — use [SteelEngine MCP](/mcp/steelengine), which uses a separate key type. To publish one workflow as a peer agent for other AI agents, see [A2A Agents](/mcp/a2a).

## Creating and Managing MCP Servers

MCP servers group your workflow tools together. Create and manage them in workspace settings:

[Video: mcp-server.mp4](https://d4h6f8f5tksdw.cloudfront.net/mcp/mcp-server.mp4)

1. Navigate to **Settings → MCP Servers**
2. Click **Add**
3. Enter a **Server Name** and an optional **Description**
4. Optionally select deployed **Workflows** to publish right away
5. Choose **Private** or **Public** under **Access**, then click **Add Server**
6. Open the server to view its URL, client configuration, and tools

## Public and Private Servers

The **Access** setting decides who can call the server:

* **Private**: Every call must carry credentials: either an OAuth Bearer token issued for this server, or an `X-API-Key` header with a Workspace, Personal, or Organization API key. The key must be authorized for the workspace and the published workflows. The server lists and runs tools with the caller's own permissions.
* **Public**: Calls need no credentials. The server ignores any credentials a client sends. Every call runs with the publisher's permissions and bills the workspace. The UI states this when you pick Public: "Anyone with the URL can run published workflows using your authority and workspace billing."

A public server keeps working only while all of the following hold for its publisher:

* They still belong to the workspace
* They are not banned
* They still hold publish permission for each workflow

Tools disappear from the server when their workflow is undeployed or archived.

Switching a server between Private and Public, or deleting it, revokes every OAuth connection made to it. Clients must connect again after the change.

Browser cookies and SteelEngine MCP keys never authenticate a workflow MCP server. The **Edit Server** hint says it directly: "SteelEngine MCP keys cannot access workflow MCP servers."

## OAuth for Private Servers

A private server is an OAuth-protected resource at:

```txt
https://steelengine.com/api/mcp/serve/{serverId}
```

Clients discover it from `https://steelengine.com/.well-known/oauth-protected-resource/api/mcp/serve/{serverId}`. That document names SteelEngine as the authorization server and advertises two scopes:

| Scope                     | Allows       |
| ------------------------- | ------------ |
| `workflow-mcp:tools:read` | `tools/list` |
| `workflow-mcp:tools:call` | `tools/call` |

An unauthenticated or expired call returns `401` with a `WWW-Authenticate` challenge that points at that discovery URL. OAuth-capable clients such as Claude.ai and Claude Code read the challenge and start or refresh the flow on their own. Access tokens last ten minutes and refresh tokens thirty days.

Each connection is a grant for one user, one client, and one server. OAuth tokens issued for SteelEngine MCP or Cost-Offload do not authenticate a workflow MCP server. The server's **Details** tab lists them under **Your connected applications**. Click **Disconnect** to revoke one. Public servers publish no discovery document and accept no tokens.

## Adding a Workflow as a Tool

Once your workflow is deployed, you can expose it as an MCP tool:

[Video: mcp-deploy-tool.mp4](https://d4h6f8f5tksdw.cloudfront.net/mcp/mcp-deploy-tool.mp4)

1. Open your deployed workflow
2. Click **Deploy** and go to the **MCP** tab
3. Configure the tool name and description
4. Add descriptions for each parameter (helps AI understand inputs)
5. Select which MCP servers to add it to

You can also click **Add Workflows** in a server's detail view to publish deployed workflows from the server side.

The workflow must be deployed before it can be added as an MCP tool.

## Tool Configuration

### Tool Name

Use lowercase letters, numbers, and underscores. The name should be descriptive and follow MCP naming conventions (e.g., `search_documents`, `send_email`).

### Description

Write a clear description of what the tool does. This helps AI assistants understand when to use the tool.

### Parameters

Your workflow's input format fields become tool parameters. Add descriptions to each parameter to help AI assistants provide correct values.

## Connecting MCP Clients

Open the server in **Settings → MCP Servers**. The **Details** tab shows the server URL and an **MCP Client** switch. The switch offers a ready-made configuration for **Cursor**, **Claude Code**, **Claude Desktop**, and **VS Code**. Click **Copy configuration** to copy the active snippet. The Cursor tab also has an **Add to Cursor** button that installs the server through a deeplink.

To find server URLs from a script, call [Discover MCP Servers](/api-reference/mcp-servers/discoverMcpServers) with an API key. It lists every workflow MCP server the key can reach, with its URL and tool count.

The generated snippets carry no credentials. In the examples below `my-workflows` is the server name, lowercased and hyphenated.

### Cursor

```json
{
  "mcpServers": {
    "my-workflows": {
      "url": "https://steelengine.com/api/mcp/serve/YOUR_SERVER_ID"
    }
  }
}
```

### Claude Code

```bash
claude mcp add --transport http "my-workflows" "https://steelengine.com/api/mcp/serve/YOUR_SERVER_ID"
```

### Claude Desktop

Claude Desktop connects through [`mcp-remote`](https://www.npmjs.com/package/mcp-remote):

```json
{
  "mcpServers": {
    "my-workflows": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://steelengine.com/api/mcp/serve/YOUR_SERVER_ID"]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "my-workflows": {
      "type": "http",
      "url": "https://steelengine.com/api/mcp/serve/YOUR_SERVER_ID"
    }
  }
}
```

### Authenticating a Private Server

For a public server the snippets work as-is. For a private server, the detail view adds: "Connect with OAuth and sign in to an account with workspace access. For API-key clients, use the X-API-Key header with a workspace-authorized key." Choose one of two options:

* Let the client run the OAuth flow. Clients that read the `WWW-Authenticate` challenge sign you in and request the `workflow-mcp:tools:*` scopes on their own.
* Add an `X-API-Key` header to the snippet yourself. Use a Workspace, Personal, or Organization API key from **Settings → API Keys** (the detail view offers a **create one now** link). The key's grants must cover the workspace or each published workflow. `tools/list` needs read access and `tools/call` needs execute access.

`/api/mcp/serve/...` rejects a SteelEngine MCP key (`sk-steelengine-...` from the **SteelEngine MCP** group). That key authenticates only [SteelEngine MCP](/mcp/steelengine).

### Using the Server Inside SteelEngine

The **SteelEngine** option of the MCP Client switch adds the server to the current workspace's **MCP Tools**. Agent blocks in other workflows can then call the published workflows. Click **Add to Workspace**. For a private server, SteelEngine creates the connection with an `X-API-Key` header set to `{{STEELENGINE_API_KEY}}`. Define that environment variable with a workspace-authorized API key before you run the agent.

## Server Management

The **Settings → MCP Servers** list shows each server's name, tool count, a **Public** badge where relevant, and a **Delete** button. Deleting a server removes it and all of its tools. Open a server to see the detail view:

* **Details** tab: **Server Name**, **Transport** (Streamable-HTTP), **Access**, **URL**, the client configuration described above, and for private servers **Your connected applications**
* **Workflows** tab: every workflow published to the server, each with **Edit** and **Remove**
* **Edit Server**: change the name, description, or **Access**
* **Add Workflows**: publish more deployed workflows to the server

## How It Works

When an MCP client calls your tool:

1. The request is received at your MCP server URL
2. SteelEngine authenticates the caller, then validates the arguments against the tool's parameter schema
3. The deployed workflow executes with the provided inputs
4. Results are returned to the MCP client

Workflows execute using the same deployment version as API calls, ensuring consistent behavior.

What the client receives:

* `tools/list` advertises each tool with its `inputSchema` and an open-object `outputSchema`. Because a workflow can have any side effect, each tool is marked as destructive and open-world (`readOnlyHint: false`, `destructiveHint: true`, `openWorldHint: true`).
* Arguments that fail the parameter schema do not run the workflow. The server returns a tool result with `isError: true` and `success: false`.
* A successful object output comes back as `structuredContent` with its fields intact. The server wraps arrays, scalars, and `null` as `{ "value": ... }`.
* A failed workflow run returns an error message with `isError: true`.

## Limits and Transport

* The endpoint accepts `POST` and `OPTIONS` only. `GET` and `DELETE` return `405`.
* Requests must send `Content-Type: application/json` (`415` otherwise) and stay under 1 MiB (`413`).
* Each server shares one rate limit across all callers, anonymous ones included: a burst of 120 requests, refilling at 60 per minute. Excess requests get `429` with a `Retry-After` header.
* The server accepts browser calls only from the SteelEngine app origin, `https://claude.ai`, `https://claude.com`, `https://chatgpt.com`, and any origins listed in the `ADDITIONAL_TRUSTED_ORIGINS` environment variable. Other origins get `403`. Requests without an `Origin` header (CLI and desktop clients) are unaffected.

## Permission Requirements

SteelEngine evaluates Permission Catalog grants, not fixed workspace tiers:

| Action                                      | Required catalog permission                                               |
| ------------------------------------------- | ------------------------------------------------------------------------- |
| View workflow MCP servers                   | `workflow_mcp_server:read`                                                |
| Create a workflow MCP server                | `workspace:manage_mcp`                                                    |
| Add a workflow while creating a server      | `workspace:manage_mcp` and `workflow:publish_mcp_tool` for every workflow |
| Update or delete a workflow MCP server      | `workflow_mcp_server:manage`                                              |
| Publish a workflow to a selected MCP server | `workflow:publish_mcp_tool` and `workflow_mcp_server:manage`              |

The authenticated user's current roles must grant every required permission. For scoped API keys, the key grant must also cover every resolved workspace or workflow at a sufficient transport level.

## Common Questions

**Does my workflow need to be deployed before adding it as an MCP tool?**

Yes. Only deployed workflows can be added as MCP tools. The MCP tool executes the same deployment version as API calls, ensuring consistent behavior between both access methods.

**What MCP protocol does SteelEngine implement?**

SteelEngine implements the standard MCP protocol over Streamable HTTP using the official MCP TypeScript SDK, supporting JSON-RPC 2.0 messages including tools/list and tools/call. The server is stateless and advertises only the tools capability.

**How do I authenticate MCP client connections?**

For a private server, either complete the OAuth flow your client starts from the 401 challenge, or send a Workspace, Personal, or Organization API key in the X-API-Key header. The server does not accept session cookies or SteelEngine MCP keys. A public server needs no credentials and ignores any it receives.

**Who is billed when a public server runs a workflow?**

The workspace that owns the server. Public calls run with the publisher's permissions, so treat the URL like a credential. Switch the server back to Private if it should stop accepting anonymous calls. Switching revokes existing OAuth connections.

**Can I add the same workflow to multiple MCP servers?**

Yes. When configuring a workflow as an MCP tool, you can select multiple MCP servers to add it to. Each server exposes its own URL, so you can organize tools into different servers for different use cases or clients.

**What naming conventions should I follow for tool names?**

Use lowercase letters, numbers, and underscores only. The name should be descriptive and follow MCP naming conventions, such as search_documents or send_email. This helps AI assistants understand and correctly invoke your tools.

**How are workflow inputs mapped to MCP tool parameters?**

Your workflow's input format fields automatically become MCP tool parameters. You can add descriptions to each parameter in the MCP configuration to help AI assistants understand what values to provide. SteelEngine validates arguments against that schema before the workflow runs.
