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

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, 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 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.

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:

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

Discover Available Tools

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

{
  "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:

{
  "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: Demonstrates basic Slack notifications via Rube MCP
• developer-growth-analysis/SKILL.md: Shows full multi-step workflows including history analysis and HackerNews integration
• composio-skills/zoho-mail-automation/SKILL.md: Illustrates email automation patterns
• composio-skills/zyte-api-automation/SKILL.md: Documents the "add MCP server" instruction pattern and tool verification workflow

Repository Metadata

The 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 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 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 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 or 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}