Skip to main content
hc
Submit
mcpSource-backedReview first Safety ✓ Privacy ✓
AWS Labs logo

AWS Step Functions Tool MCP Server

Official AWS Labs MCP server that exposes selected AWS Step Functions state machines as MCP tools without code changes, letting AI assistants run existing Standard and Express workflows that coordinate work across AWS services.

by AWS Labs·added 2026-06-21·
Claude CodeCodexCursorClaude Desktop
HarnessClaude CodeCodexCursorClaude Desktop
Review first — review before installing

Open the source and read safety notes before installing.

Citation facts

Source-backed facts for citing this resource, derived directly from the registry — also available as plain text for AI assistants.

Canonical URL
https://heyclau.de/entry/mcp/aws-stepfunctions-tool-mcp-server
Source URLs
https://github.com/awslabs/mcp/blob/main/src/stepfunctions-tool-mcp-server/README.md, https://github.com/awslabs/mcp, https://awslabs.github.io/mcp/
Brand
AWS Labs
Brand domain
aws.amazon.com
Brand asset source
brandfetch
Safety notes
Only state machines matching your `STATE_MACHINE_PREFIX`/`STATE_MACHINE_LIST`/`STATE_MACHINE_TAG_*` allowlist are exposed; scope this narrowly so the model can run just the intended workflows., The client only needs permission to start executions; each state machine uses its own IAM role to reach other AWS services (separation of duties). Running a workflow executes whatever it does, including writes, so only allowlist machines you trust the model to run., This server starts real Step Functions executions with your AWS credentials; scope the profile narrowly and run it only on a trusted host.
Privacy notes
State machine names, ARNs, execution inputs, and outputs pass through the model; an executed workflow can read or write whatever its own role allows., Keep account identifiers, credentials, and sensitive execution inputs/outputs out of public prompts, issues, and screenshots.
Author
AWS Labs
Submitted by
jaso0n0818
Claim status
unclaimed
Last verified
2026-06-21

Safety notes

  • Only state machines matching your `STATE_MACHINE_PREFIX`/`STATE_MACHINE_LIST`/`STATE_MACHINE_TAG_*` allowlist are exposed; scope this narrowly so the model can run just the intended workflows.
  • The client only needs permission to start executions; each state machine uses its own IAM role to reach other AWS services (separation of duties). Running a workflow executes whatever it does, including writes, so only allowlist machines you trust the model to run.
  • This server starts real Step Functions executions with your AWS credentials; scope the profile narrowly and run it only on a trusted host.

Privacy notes

  • State machine names, ARNs, execution inputs, and outputs pass through the model; an executed workflow can read or write whatever its own role allows.
  • Keep account identifiers, credentials, and sensitive execution inputs/outputs out of public prompts, issues, and screenshots.

Prerequisites

  • An AWS account with the Step Functions state machines you want to expose, and permission to start their executions.
  • Python 3.10 or newer and `uv` / `uvx` installed (Astral) to run the package.
  • AWS credentials configured locally (for example via `aws configure` or `AWS_PROFILE`) scoped to start executions on the allowlisted state machines only.
  • An allowlist of state machines via `STATE_MACHINE_PREFIX`, `STATE_MACHINE_LIST`, or `STATE_MACHINE_TAG_KEY`/`STATE_MACHINE_TAG_VALUE`; only matching machines are exposed.
  • An MCP client that supports stdio servers; the server runs locally on the same host as the client.

Schema details

Install type
cli
Troubleshooting
No
Source repository stats
Scope
Source repo
Collection metadata
Estimated setup
15 minutes
Difficulty
advanced
Tool listing metadata
Pricing
open-source
Disclosure
editorial
Application category
DeveloperApplication
Operating system
Cross-platform
Full copyable content
{
  "awslabs.stepfunctions-tool-mcp-server": {
    "command": "uvx",
    "args": ["awslabs.stepfunctions-tool-mcp-server@latest"],
    "env": {
      "AWS_PROFILE": "${AWS_PROFILE}",
      "AWS_REGION": "us-east-1",
      "STATE_MACHINE_PREFIX": "your-state-machine-prefix",
      "STATE_MACHINE_LIST": "your-first-state-machine,your-second-state-machine",
      "STATE_MACHINE_TAG_KEY": "your-tag-key",
      "STATE_MACHINE_TAG_VALUE": "your-tag-value"
    }
  }
}

About this resource

Overview

AWS Step Functions Tool MCP Server is an official AWS Labs Model Context Protocol server that selects and runs AWS Step Functions state machines as MCP tools without code changes. It bridges MCP clients and Step Functions so an AI model can execute existing workflows that coordinate multi-step business processes across AWS services — with no changes to the state machine definitions.

It runs locally over stdio via uvx from the published awslabs.stepfunctions-tool-mcp-server Python package and uses your local AWS credentials. You choose which state machines are exposed through an allowlist.

Features

  • Workflows as tools — expose selected state machines to the model as MCP tools, with no changes to their definitions.
  • Standard and Express — supports long-running Standard workflows and high-volume, synchronous Express workflows.
  • Allowlisting — scope which machines are available via prefix, list, or tags.
  • Schema-aware docs — integrates with EventBridge Schema Registry for input validation and richer tool documentation.
  • Separation of duties — the client only starts executions; each machine uses its own IAM role for downstream AWS access.

Use Cases

  • Let Claude trigger an existing approval or data-processing workflow.
  • Expose a curated set of operational state machines as safe, named tools.
  • Reuse multi-service Step Functions orchestration as model tools.
  • Keep broad AWS permissions in machine roles while the client stays minimal.

Installation

Claude Code

  1. Install Python 3.10+ and uv.
  2. Configure an AWS profile scoped to start executions on your state machines.
  3. Add the server with the stdio configuration above and set an allowlist (STATE_MACHINE_PREFIX, STATE_MACHINE_LIST, or STATE_MACHINE_TAG_*).
  4. Verify it is connected with claude mcp list.

Claude Desktop / Cursor / Kiro / VS Code

Add the configSnippet above to your client's MCP configuration, set AWS_PROFILE/AWS_REGION, and define the state-machine allowlist. The first run downloads the package via uvx.

Source And Trust

This entry is based on the official AWS Labs awslabs/mcp repository and the published PyPI package (Apache-2.0). The server starts real Step Functions executions with your AWS credentials, so keep the client scoped to start-only, allowlist machines narrowly, and verify the configuration against the linked source before using it in automated workflows.

#aws#step-functions#workflows#tools#aws-labs

Source citations

Add this badge to your README

Show that AWS Step Functions Tool MCP Server is listed on HeyClaude. Paste this Markdown into your README — it renders the badge and links back to this page.

Listed on HeyClaude
[![Listed on HeyClaude](https://heyclau.de/badge/mcp/aws-stepfunctions-tool-mcp-server.svg)](https://heyclau.de/entry/mcp/aws-stepfunctions-tool-mcp-server)

How it compares

AWS Step Functions Tool MCP Server side by side with 3 alternatives on trust, install, platform support, and disclosed safety notes — all from reviewed registry metadata.

Field
AWS Labs logoAWS Step Functions Tool MCP Server

Official AWS Labs MCP server that exposes selected AWS Step Functions state machines as MCP tools without code changes, letting AI assistants run existing Standard and Express workflows that coordinate work across AWS services.

Open dossier
AWS Labs logoAWS Lambda Tool MCP Server

Official AWS Labs MCP server that exposes selected AWS Lambda functions as MCP tools without code changes, letting AI assistants invoke your allowlisted functions to reach private resources, databases, and internal applications.

Open dossier
AWS Labs logoAmazon ECS MCP Server

Official AWS Labs MCP server for Amazon ECS that helps AI assistants containerize applications, deploy them to ECS, troubleshoot deployments, and explore ECS and ECR resources across the container application lifecycle.

Open dossier
AWS Labs logoAmazon EKS MCP Server

Official AWS Labs MCP server for Amazon EKS that gives AI code assistants real-time cluster state visibility and Kubernetes/EKS resource management, from cluster setup through deployment, troubleshooting, and optimization.

Open dossier
Trust
Install riskReview firstReview firstReview firstReview first
Notes Safety ✓ Privacy ✓ Safety ✓ Privacy ✓ Safety ✓ Privacy ✓ Safety ✓ Privacy ✓
BrandAWS Labs logoAWS LabsAWS Labs logoAWS LabsAWS Labs logoAWS LabsAWS Labs logoAWS Labs
Categorymcpmcpmcpmcp
Sourcesource-backedsource-backedsource-backedsource-backed
AuthorAWS LabsAWS LabsAWS LabsAWS Labs
Added2026-06-212026-06-212026-06-212026-06-21
Platforms
Claude CodeCodexCursorClaude Desktop
Claude CodeClaude Desktop
Claude CodeClaude Desktop
Claude CodeClaude Desktop
Source repo————
Safety notes✓Only state machines matching your `STATE_MACHINE_PREFIX`/`STATE_MACHINE_LIST`/`STATE_MACHINE_TAG_*` allowlist are exposed; scope this narrowly so the model can run just the intended workflows. The client only needs permission to start executions; each state machine uses its own IAM role to reach other AWS services (separation of duties). Running a workflow executes whatever it does, including writes, so only allowlist machines you trust the model to run. This server starts real Step Functions executions with your AWS credentials; scope the profile narrowly and run it only on a trusted host.✓Only functions matching your `FUNCTION_PREFIX`/`FUNCTION_LIST`/`FUNCTION_TAG_*` allowlist are exposed; scope this narrowly so the model can invoke just the intended functions. By design the client only needs `lambda:InvokeFunction`; each function uses its own execution role to reach other AWS services, keeping segregation of duties. Invoking a function runs whatever that function does (including writes), so only allowlist functions you trust the model to call. This server invokes real Lambda functions with your AWS credentials; scope the profile to invoke-only on the allowlisted functions and run it only on a trusted host.✓The configuration above is read-only. Setting `ALLOW_WRITE=true` lets the server create and modify infrastructure (ECR repos, CloudFormation stacks, ECS services) and `ALLOW_SENSITIVE_DATA=true` exposes logs; enable these only deliberately. AWS documents this server as primarily for development, testing, and non-critical environments; keep write/sensitive-data disabled for production accounts and prefer non-production targets while evaluating it. This server acts on real infrastructure with your AWS credentials; scope the profile to the intended account, region, and resources, and run it only on a trusted host.✓The configuration above is read-only. Adding the `--allow-write` flag lets the server create, update, patch, and delete EKS/Kubernetes resources (including creating clusters via CloudFormation) and `--allow-sensitive-data-access` exposes logs and events; enable these only deliberately. This server acts on real infrastructure with your AWS credentials; scope the profile to the intended account, region, and clusters, and prefer non-production targets while evaluating it. Run it only on a trusted host, and review any generated manifests or CloudFormation actions before applying them.
Privacy notes✓State machine names, ARNs, execution inputs, and outputs pass through the model; an executed workflow can read or write whatever its own role allows. Keep account identifiers, credentials, and sensitive execution inputs/outputs out of public prompts, issues, and screenshots.✓Function names, ARNs, input arguments, and returned payloads pass through the model; an invoked function can read or write whatever its own role allows. Keep account identifiers, credentials, and sensitive function inputs/outputs out of public prompts, issues, and screenshots.✓Cluster, service, task, task-definition, and ECR metadata plus account/region identifiers can be returned through tool calls and exposed to the model. With sensitive-data access enabled, logs and deployment details may be returned; keep account identifiers, credentials, and log contents out of public prompts, issues, and screenshots.✓Cluster state, resource manifests, ARNs, and account/region metadata can be returned through tool calls and exposed to the model. With sensitive-data access enabled, pod logs and Kubernetes events may be returned; keep account identifiers, credentials, and log contents out of public prompts, issues, and screenshots.
Prerequisites
  • An AWS account with the Step Functions state machines you want to expose, and permission to start their executions.
  • Python 3.10 or newer and `uv` / `uvx` installed (Astral) to run the package.
  • AWS credentials configured locally (for example via `aws configure` or `AWS_PROFILE`) scoped to start executions on the allowlisted state machines only.
  • An allowlist of state machines via `STATE_MACHINE_PREFIX`, `STATE_MACHINE_LIST`, or `STATE_MACHINE_TAG_KEY`/`STATE_MACHINE_TAG_VALUE`; only matching machines are exposed.
  • An AWS account with the Lambda functions you want to expose, and permission to invoke them.
  • Python 3.10 or newer and `uv` / `uvx` installed (Astral) to run the package.
  • AWS credentials configured locally (for example via `aws configure` or `AWS_PROFILE`) scoped to `lambda:InvokeFunction` for the allowlisted functions only.
  • An allowlist of functions via `FUNCTION_PREFIX`, `FUNCTION_LIST`, or `FUNCTION_TAG_KEY`/`FUNCTION_TAG_VALUE`; only matching functions are exposed as tools.
  • An AWS account with Amazon ECS/ECR and permissions to view (and, if enabled, deploy) the target resources.
  • Docker or Finch for containerization and local image builds.
  • Python 3.10 or newer and `uv` / `uvx` installed (Astral) to run the package.
  • AWS credentials configured locally (for example via `aws configure` or `AWS_PROFILE`) scoped to the intended account, region, and resources.
  • An AWS account with Amazon EKS and permissions to view (and, if enabled, manage) the target clusters.
  • Python 3.10 or newer and `uv` / `uvx` installed (Astral) to run the package.
  • AWS credentials configured locally (for example via `aws configure` or `AWS_PROFILE`) scoped to the intended account, region, and clusters.
  • An MCP client that supports stdio servers; the server runs locally on the same host as the client.
Install
uvx awslabs.stepfunctions-tool-mcp-server@latest
uvx awslabs.lambda-tool-mcp-server@latest
uvx --from awslabs-ecs-mcp-server ecs-mcp-server
uvx awslabs.eks-mcp-server@latest
Config
{
  "mcpServers": {
    "awslabs.stepfunctions-tool-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.stepfunctions-tool-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "${AWS_PROFILE}",
        "AWS_REGION": "us-east-1",
        "STATE_MACHINE_PREFIX": "your-state-machine-prefix",
        "STATE_MACHINE_LIST": "your-first-state-machine,your-second-state-machine",
        "STATE_MACHINE_TAG_KEY": "your-tag-key",
        "STATE_MACHINE_TAG_VALUE": "your-tag-value"
      },
      "type": "stdio"
    }
  }
}
{
  "mcpServers": {
    "awslabs.lambda-tool-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.lambda-tool-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "${AWS_PROFILE}",
        "AWS_REGION": "us-east-1",
        "FUNCTION_PREFIX": "your-function-prefix",
        "FUNCTION_LIST": "your-first-function,your-second-function",
        "FUNCTION_TAG_KEY": "your-tag-key",
        "FUNCTION_TAG_VALUE": "your-tag-value"
      },
      "type": "stdio"
    }
  }
}
{
  "mcpServers": {
    "awslabs.ecs-mcp-server": {
      "command": "uvx",
      "args": ["--from", "awslabs-ecs-mcp-server", "ecs-mcp-server"],
      "env": {
        "AWS_PROFILE": "${AWS_PROFILE}",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR",
        "ALLOW_WRITE": "false",
        "ALLOW_SENSITIVE_DATA": "false"
      },
      "type": "stdio"
    }
  }
}
{
  "mcpServers": {
    "awslabs.eks-mcp-server": {
      "command": "uvx",
      "args": ["awslabs.eks-mcp-server@latest"],
      "env": {
        "AWS_PROFILE": "${AWS_PROFILE}",
        "AWS_REGION": "us-east-1",
        "FASTMCP_LOG_LEVEL": "ERROR"
      },
      "type": "stdio"
    }
  }
}
Citations
ClaimUnclaimedUnclaimedUnclaimedUnclaimed

Related guides

Source-backed guides for putting this to work.

AWS logoguides

Claude Code on Amazon Bedrock Setup

Configure Claude Code to run on Amazon Bedrock with correct AWS auth.

Review firstSource-backedReview firstAdded 9d ago
Safety ✓ Privacy ✓
AWS logoguides

Claude Code vs Amazon Q Developer vs Gemini Code Assist

Compare Claude Code, Amazon Q Developer (formerly CodeWhisperer), and Google Gemini Code Assist on form factor, agentic features, and ecosystem fit.

Review firstSource-backedReview firstAdded 8mo ago
Safety · Privacy ✓
guides

Creating Output Styles for Non-Coding Claude Workflows

Build Claude Code output styles for PM, support, and writing workflows without coding defaults.

Review firstSource-backedReview firstAdded 9d ago
Safety ✓ Privacy ✓

Signals

Loading live community signals…

More like this, weekly

A short, calm digest of reviewed Claude resources. Unsubscribe any time.