# How to Automate App Workflows Using Composio's Rube MCP with Claude Skills

> Automate app workflows with Composio's Rube MCP and Claude Skills. This zero-code solution uses a unified API for seamless integration, eliminating custom code.

- Repository: [Composio/awesome-claude-skills](https://github.com/composiohq/awesome-claude-skills)
- Tags: how-to-guide
- Published: 2026-07-28

---

**Composio's Rube MCP enables zero-code workflow automation by exposing a unified JSON-RPC-like API that Claude skills invoke through standardized tool discovery and execution commands, eliminating the need for custom integration code.**

The ComposioHQ/awesome-claude-skills repository demonstrates how to automate app workflows using Composio's Rube MCP with Claude Skills through declarative markdown definitions. This architecture allows Claude to orchestrate multi-step processes across Slack, GitHub, Google Sheets, and other services without handling OAuth flows or API implementations directly.

## Understanding the Rube MCP Architecture

### The Gateway Server

Rube MCP (Multi-Channel Protocol) operates as a lightweight, self-hosted gateway that forwards tool calls to appropriate third-party services. According to the implementation in [`skill-share/SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/skill-share/SKILL.md), Claude contacts the server through built-in `RUBE_SEARCH_TOOLS` and `RUBE_MULTI_EXECUTE_TOOL` commands, abstracting underlying service complexity behind a uniform endpoint such as `https://rube.app/mcp`.

### Skill Definitions and Tool Discovery

Each workflow resides in a markdown [`SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/SKILL.md) file that defines steps, required tools, and parameters. Before execution, the skill validates connectivity using `RUBE_SEARCH_TOOLS` to discover exact tool names like `SLACK_SEND_MESSAGE` or `GOOGLE_SHEETS_APPEND_ROWS`. This dynamic discovery makes workflows portable—the skill automatically adapts if integration implementations change, as demonstrated in [`developer-growth-analysis/SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/developer-growth-analysis/SKILL.md).

### Execution Pipeline and Result Handling

Once tools are identified, Claude constructs a payload for `RUBE_MULTI_EXECUTE_TOOL` containing multiple actions that Rube executes sequentially. Rube returns raw responses that Claude formats into user-friendly output—markdown tables, files, or direct posts back to services like Slack or GitHub.

## Building Multi-Step Workflows

### Configure the MCP Server

Add the Rube MCP endpoint to your client configuration to enable communication:

```json
{
  "mcpServers": ["https://rube.app/mcp"]
}

```

### Discover Available Tools

Query the Rube MCP server to identify available integrations and their specific tool identifiers:

```json
{
  "tool": "RUBE_SEARCH_TOOLS",
  "parameters": {
    "category": "slack"
  }
}

```

Claude receives a response containing available tools such as `["SLACK_SEND_MESSAGE", "SLACK_FIND_CHANNELS", ...]`, enabling precise tool selection without hardcoding API endpoints.

### Execute Complex Workflows

Construct a payload with multiple sequential actions using `RUBE_MULTI_EXECUTE_TOOL`:

```json
{
  "tool": "RUBE_MULTI_EXECUTE_TOOL",
  "parameters": {
    "actions": [
      {
        "name": "SLACK_FIND_CHANNELS",
        "input": { "query": "#automation" }
      },
      {
        "name": "SLACK_SEND_MESSAGE",
        "input": {
          "channel_id": "${previousAction.channel_id}",
          "text": "🚀 New workflow triggered – creating a GitHub issue..."
        }
      },
      {
        "name": "GITHUB_CREATE_ISSUE",
        "input": {
          "owner": "my-org",
          "repo": "my-app",
          "title": "Automated task from Claude",
          "body": "Generated by Claude skill via Rube MCP."
        }
      }
    ]
  }
}

```

This payload demonstrates chained execution where the channel ID from the first action feeds into the second, followed by cross-service orchestration to GitHub.

## Reference Implementation Files

### Core Skill Examples

The repository contains several canonical implementations demonstrating how to automate app workflows:

- **[`skill-share/SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/skill-share/SKILL.md)**: Demonstrates basic Slack notifications via Rube MCP
- **[`developer-growth-analysis/SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/developer-growth-analysis/SKILL.md)**: Shows full multi-step workflows including history analysis and HackerNews integration
- **[`composio-skills/zoho-mail-automation/SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/composio-skills/zoho-mail-automation/SKILL.md)**: Illustrates email automation patterns
- **[`composio-skills/zyte-api-automation/SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/composio-skills/zyte-api-automation/SKILL.md)**: Documents the "add MCP server" instruction pattern and tool verification workflow

### Repository Metadata

The [`opencode.json`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/opencode.json) file contains repository-wide metadata used by the Opencode engine for skill discovery and indexing.

## Architectural Benefits

- **Zero-code orchestration**: Workflow logic lives entirely in markdown [`SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/SKILL.md) files without Python or Node.js dependencies
- **Dynamic adaptation**: Tool discovery ensures skills remain functional when underlying integrations update, preventing workflow breakage
- **Centralized security**: Rube handles all OAuth flows; skills never access service credentials directly
- **Extensible payloads**: JSON-serializable data structures support complex branching logic and variable interpolation between steps

## Summary

- Rube MCP provides a unified JSON-RPC-like gateway for all Composio integrations through a single self-hosted endpoint
- Claude skills use `RUBE_SEARCH_TOOLS` for dynamic discovery and `RUBE_MULTI_EXECUTE_TOOL` for multi-step execution
- Workflows are defined declaratively in [`SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/SKILL.md) files within the `ComposioHQ/awesome-claude-skills` repository
- The architecture supports chained actions across multiple services without custom code or credential management
- Security and authentication are handled centrally by the Rube gateway, not individual skills

## Frequently Asked Questions

### What is the difference between Rube MCP and standard API integrations?

Rube MCP provides a standardized JSON-RPC-like abstraction layer that handles authentication, rate limiting, and protocol translation automatically. Unlike direct API integrations that require managing multiple SDKs and OAuth flows, Rube exposes uniform `RUBE_SEARCH_TOOLS` and `RUBE_MULTI_EXECUTE_TOOL` commands that work identically across Slack, GitHub, Google Sheets, and other services.

### Do I need to write code to create a new Claude skill with Rube MCP?

No additional code is required. Skills are defined entirely in markdown [`SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/SKILL.md) files that specify the workflow steps and tool parameters. You can copy patterns from existing skills in the repository—such as those in [`skill-share/SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/skill-share/SKILL.md) or [`developer-growth-analysis/SKILL.md`](https://github.com/ComposioHQ/awesome-claude-skills/blob/main/developer-growth-analysis/SKILL.md)—and modify the tool names and payloads to target different applications.

### How does tool discovery prevent workflow breakage?

Before execution, skills call `RUBE_SEARCH_TOOLS` to retrieve current tool names and schemas. This ensures that if Composio updates an integration (for example, renaming `SLACK_POST_MESSAGE` to `SLACK_SEND_MESSAGE`), the skill automatically uses the correct identifier without manual code updates, maintaining workflow portability.

### Can Rube MCP handle workflows that span multiple services in one transaction?

Yes. The `RUBE_MULTI_EXECUTE_TOOL` command accepts an array of actions that execute sequentially within a single payload. You can chain operations across different services—such as reading from Slack, writing to Google Sheets, and creating GitHub issues—while using variable interpolation like `${previousAction.channel_id}` to pass data between steps.