Add automation skills for all 874 Composio toolkits

- 832 new automation skills covering every toolkit on composio.dev
- Updated 78 existing skills with composio.dev/toolkits links
- Total: 910 automation skills
- Each skill includes toolkit slug, connection flow, tool discovery
  pattern, and links to composio.dev toolkit docs
- All skills include "Powered by Composio" attribution

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

-21risk-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: -21risk-automation
+description: "Automate 21risk tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# 21risk Automation via Rube MCP
+
+Automate 21risk operations through Composio's 21risk toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/_21risk](https://composio.dev/toolkits/_21risk)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active 21risk connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `_21risk`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `_21risk`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "21risk operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific 21risk task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["_21risk"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with 21risk-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `_21risk` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

-2chat-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: -2chat-automation
+description: "Automate 2chat tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# 2chat Automation via Rube MCP
+
+Automate 2chat operations through Composio's 2chat toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/_2chat](https://composio.dev/toolkits/_2chat)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active 2chat connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `_2chat`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `_2chat`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "2chat operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific 2chat task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["_2chat"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with 2chat-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `_2chat` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

ably-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: ably-automation
+description: "Automate Ably tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Ably Automation via Rube MCP
+
+Automate Ably operations through Composio's Ably toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/ably](https://composio.dev/toolkits/ably)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Ably connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ably`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `ably`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Ably operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Ably task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["ably"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Ably-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ably` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

abstract-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: abstract-automation
+description: "Automate Abstract tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Abstract Automation via Rube MCP
+
+Automate Abstract operations through Composio's Abstract toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/abstract](https://composio.dev/toolkits/abstract)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Abstract connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `abstract`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `abstract`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Abstract operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Abstract task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["abstract"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Abstract-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `abstract` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

abuselpdb-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: abuselpdb-automation
+description: "Automate Abuselpdb tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Abuselpdb Automation via Rube MCP
+
+Automate Abuselpdb operations through Composio's Abuselpdb toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/abuselpdb](https://composio.dev/toolkits/abuselpdb)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Abuselpdb connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `abuselpdb`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `abuselpdb`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Abuselpdb operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Abuselpdb task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["abuselpdb"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Abuselpdb-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `abuselpdb` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

abyssale-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: abyssale-automation
+description: "Automate Abyssale tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Abyssale Automation via Rube MCP
+
+Automate Abyssale operations through Composio's Abyssale toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/abyssale](https://composio.dev/toolkits/abyssale)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Abyssale connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `abyssale`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `abyssale`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Abyssale operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Abyssale task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["abyssale"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Abyssale-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `abyssale` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

accelo-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: accelo-automation
+description: "Automate Accelo tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Accelo Automation via Rube MCP
+
+Automate Accelo operations through Composio's Accelo toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/accelo](https://composio.dev/toolkits/accelo)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Accelo connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `accelo`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `accelo`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Accelo operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Accelo task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["accelo"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Accelo-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `accelo` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

accredible-certificates-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: accredible-certificates-automation
+description: "Automate Accredible Certificates tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Accredible Certificates Automation via Rube MCP
+
+Automate Accredible Certificates operations through Composio's Accredible Certificates toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/accredible_certificates](https://composio.dev/toolkits/accredible_certificates)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Accredible Certificates connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `accredible_certificates`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `accredible_certificates`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Accredible Certificates operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Accredible Certificates task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["accredible_certificates"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Accredible Certificates-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `accredible_certificates` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

acculynx-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: acculynx-automation
+description: "Automate Acculynx tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Acculynx Automation via Rube MCP
+
+Automate Acculynx operations through Composio's Acculynx toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/acculynx](https://composio.dev/toolkits/acculynx)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Acculynx connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `acculynx`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `acculynx`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Acculynx operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Acculynx task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["acculynx"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Acculynx-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `acculynx` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

active-campaign-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: active-campaign-automation
+description: "Automate ActiveCampaign tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# ActiveCampaign Automation via Rube MCP
+
+Automate ActiveCampaign operations through Composio's ActiveCampaign toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/active_campaign](https://composio.dev/toolkits/active_campaign)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active ActiveCampaign connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `active_campaign`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `active_campaign`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "ActiveCampaign operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific ActiveCampaign task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["active_campaign"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with ActiveCampaign-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `active_campaign` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

activecampaign-automation/SKILL.md

@@ -9,6 +9,8 @@ requires:
 
 Automate ActiveCampaign CRM and marketing automation operations through Composio's ActiveCampaign toolkit via Rube MCP.
 
+**Toolkit docs**: [composio.dev/toolkits/active_campaign](https://composio.dev/toolkits/active_campaign)
+
 ## Prerequisites
 
 - Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
@@ -207,3 +209,6 @@ Automate ActiveCampaign CRM and marketing automation operations through Composio
 | Subscribe/unsubscribe | ACTIVE_CAMPAIGN_MANAGE_LIST_SUBSCRIPTION | action, list_id, email |
 | Add to automation | ACTIVE_CAMPAIGN_ADD_CONTACT_TO_AUTOMATION | contact_email, automation_id |
 | Create task | ACTIVE_CAMPAIGN_CREATE_CONTACT_TASK | relid, duedate, dealTasktype, title |
+
+---
+*Powered by [Composio](https://composio.dev)*

addresszen-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: addresszen-automation
+description: "Automate Addresszen tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Addresszen Automation via Rube MCP
+
+Automate Addresszen operations through Composio's Addresszen toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/addresszen](https://composio.dev/toolkits/addresszen)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Addresszen connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `addresszen`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `addresszen`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Addresszen operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Addresszen task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["addresszen"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Addresszen-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `addresszen` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

adobe-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: adobe-automation
+description: "Automate Adobe tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Adobe Automation via Rube MCP
+
+Automate Adobe operations through Composio's Adobe toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/adobe](https://composio.dev/toolkits/adobe)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Adobe connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `adobe`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `adobe`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Adobe operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Adobe task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["adobe"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Adobe-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `adobe` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

adrapid-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: adrapid-automation
+description: "Automate Adrapid tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Adrapid Automation via Rube MCP
+
+Automate Adrapid operations through Composio's Adrapid toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/adrapid](https://composio.dev/toolkits/adrapid)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Adrapid connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `adrapid`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `adrapid`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Adrapid operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Adrapid task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["adrapid"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Adrapid-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `adrapid` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

adyntel-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: adyntel-automation
+description: "Automate Adyntel tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Adyntel Automation via Rube MCP
+
+Automate Adyntel operations through Composio's Adyntel toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/adyntel](https://composio.dev/toolkits/adyntel)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Adyntel connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `adyntel`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `adyntel`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Adyntel operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Adyntel task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["adyntel"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Adyntel-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `adyntel` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

aero-workflow-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: aero-workflow-automation
+description: "Automate Aero Workflow tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Aero Workflow Automation via Rube MCP
+
+Automate Aero Workflow operations through Composio's Aero Workflow toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/aero_workflow](https://composio.dev/toolkits/aero_workflow)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Aero Workflow connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `aero_workflow`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `aero_workflow`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Aero Workflow operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Aero Workflow task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["aero_workflow"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Aero Workflow-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `aero_workflow` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

aeroleads-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: aeroleads-automation
+description: "Automate Aeroleads tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Aeroleads Automation via Rube MCP
+
+Automate Aeroleads operations through Composio's Aeroleads toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/aeroleads](https://composio.dev/toolkits/aeroleads)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Aeroleads connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `aeroleads`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `aeroleads`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Aeroleads operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Aeroleads task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["aeroleads"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Aeroleads-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `aeroleads` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

affinda-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: affinda-automation
+description: "Automate Affinda tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Affinda Automation via Rube MCP
+
+Automate Affinda operations through Composio's Affinda toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/affinda](https://composio.dev/toolkits/affinda)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Affinda connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `affinda`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `affinda`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Affinda operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Affinda task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["affinda"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Affinda-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `affinda` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

affinity-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: affinity-automation
+description: "Automate Affinity tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Affinity Automation via Rube MCP
+
+Automate Affinity operations through Composio's Affinity toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/affinity](https://composio.dev/toolkits/affinity)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Affinity connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `affinity`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `affinity`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Affinity operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Affinity task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["affinity"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Affinity-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `affinity` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

agencyzoom-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: agencyzoom-automation
+description: "Automate Agencyzoom tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Agencyzoom Automation via Rube MCP
+
+Automate Agencyzoom operations through Composio's Agencyzoom toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/agencyzoom](https://composio.dev/toolkits/agencyzoom)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Agencyzoom connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `agencyzoom`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `agencyzoom`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Agencyzoom operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Agencyzoom task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["agencyzoom"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Agencyzoom-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `agencyzoom` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

agent-mail-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: agent-mail-automation
+description: "Automate Agent Mail tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Agent Mail Automation via Rube MCP
+
+Automate Agent Mail operations through Composio's Agent Mail toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/agent_mail](https://composio.dev/toolkits/agent_mail)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Agent Mail connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `agent_mail`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `agent_mail`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Agent Mail operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Agent Mail task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["agent_mail"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Agent Mail-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `agent_mail` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

agentql-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: agentql-automation
+description: "Automate Agentql tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Agentql Automation via Rube MCP
+
+Automate Agentql operations through Composio's Agentql toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/agentql](https://composio.dev/toolkits/agentql)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Agentql connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `agentql`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `agentql`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Agentql operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Agentql task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["agentql"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Agentql-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `agentql` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

agenty-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: agenty-automation
+description: "Automate Agenty tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Agenty Automation via Rube MCP
+
+Automate Agenty operations through Composio's Agenty toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/agenty](https://composio.dev/toolkits/agenty)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Agenty connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `agenty`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `agenty`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Agenty operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Agenty task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["agenty"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Agenty-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `agenty` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

agiled-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: agiled-automation
+description: "Automate Agiled tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Agiled Automation via Rube MCP
+
+Automate Agiled operations through Composio's Agiled toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/agiled](https://composio.dev/toolkits/agiled)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Agiled connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `agiled`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `agiled`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Agiled operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Agiled task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["agiled"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Agiled-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `agiled` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

agility-cms-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: agility-cms-automation
+description: "Automate Agility CMS tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Agility CMS Automation via Rube MCP
+
+Automate Agility CMS operations through Composio's Agility CMS toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/agility_cms](https://composio.dev/toolkits/agility_cms)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Agility CMS connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `agility_cms`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `agility_cms`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Agility CMS operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Agility CMS task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["agility_cms"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Agility CMS-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `agility_cms` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

ahrefs-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: ahrefs-automation
+description: "Automate Ahrefs tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Ahrefs Automation via Rube MCP
+
+Automate Ahrefs operations through Composio's Ahrefs toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/ahrefs](https://composio.dev/toolkits/ahrefs)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Ahrefs connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ahrefs`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `ahrefs`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Ahrefs operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Ahrefs task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["ahrefs"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Ahrefs-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ahrefs` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

ai-ml-api-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: ai-ml-api-automation
+description: "Automate AI ML API tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# AI ML API Automation via Rube MCP
+
+Automate AI ML API operations through Composio's AI ML API toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/ai_ml_api](https://composio.dev/toolkits/ai_ml_api)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active AI ML API connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ai_ml_api`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `ai_ml_api`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "AI ML API operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific AI ML API task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["ai_ml_api"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with AI ML API-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ai_ml_api` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

airtable-automation/SKILL.md

@@ -9,6 +9,8 @@ requires:
 
 Automate Airtable operations through Composio's Airtable toolkit via Rube MCP.
 
+**Toolkit docs**: [composio.dev/toolkits/airtable](https://composio.dev/toolkits/airtable)
+
 ## Prerequisites
 
 - Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
@@ -168,3 +170,6 @@ Automate Airtable operations through Composio's Airtable toolkit via Rube MCP.
 | Update field | AIRTABLE_UPDATE_FIELD | baseId, tableIdOrName, fieldId |
 | Update table | AIRTABLE_UPDATE_TABLE | baseId, tableIdOrName, name |
 | List comments | AIRTABLE_LIST_COMMENTS | baseId, tableIdOrName, recordId |
+
+---
+*Powered by [Composio](https://composio.dev)*

aivoov-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: aivoov-automation
+description: "Automate Aivoov tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Aivoov Automation via Rube MCP
+
+Automate Aivoov operations through Composio's Aivoov toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/aivoov](https://composio.dev/toolkits/aivoov)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Aivoov connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `aivoov`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `aivoov`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Aivoov operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Aivoov task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["aivoov"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Aivoov-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `aivoov` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

alchemy-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: alchemy-automation
+description: "Automate Alchemy tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Alchemy Automation via Rube MCP
+
+Automate Alchemy operations through Composio's Alchemy toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/alchemy](https://composio.dev/toolkits/alchemy)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Alchemy connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `alchemy`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `alchemy`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Alchemy operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Alchemy task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["alchemy"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Alchemy-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `alchemy` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

algodocs-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: algodocs-automation
+description: "Automate Algodocs tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Algodocs Automation via Rube MCP
+
+Automate Algodocs operations through Composio's Algodocs toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/algodocs](https://composio.dev/toolkits/algodocs)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Algodocs connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `algodocs`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `algodocs`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Algodocs operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Algodocs task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["algodocs"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Algodocs-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `algodocs` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

algolia-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: algolia-automation
+description: "Automate Algolia tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Algolia Automation via Rube MCP
+
+Automate Algolia operations through Composio's Algolia toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/algolia](https://composio.dev/toolkits/algolia)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Algolia connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `algolia`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `algolia`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Algolia operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Algolia task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["algolia"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Algolia-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `algolia` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

all-images-ai-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: all-images-ai-automation
+description: "Automate All Images AI tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# All Images AI Automation via Rube MCP
+
+Automate All Images AI operations through Composio's All Images AI toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/all_images_ai](https://composio.dev/toolkits/all_images_ai)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active All Images AI connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `all_images_ai`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `all_images_ai`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "All Images AI operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific All Images AI task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["all_images_ai"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with All Images AI-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `all_images_ai` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

alpha-vantage-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: alpha-vantage-automation
+description: "Automate Alpha Vantage tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Alpha Vantage Automation via Rube MCP
+
+Automate Alpha Vantage operations through Composio's Alpha Vantage toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/alpha_vantage](https://composio.dev/toolkits/alpha_vantage)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Alpha Vantage connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `alpha_vantage`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `alpha_vantage`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Alpha Vantage operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Alpha Vantage task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["alpha_vantage"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Alpha Vantage-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `alpha_vantage` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

altoviz-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: altoviz-automation
+description: "Automate Altoviz tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Altoviz Automation via Rube MCP
+
+Automate Altoviz operations through Composio's Altoviz toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/altoviz](https://composio.dev/toolkits/altoviz)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Altoviz connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `altoviz`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `altoviz`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Altoviz operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Altoviz task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["altoviz"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Altoviz-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `altoviz` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

alttext-ai-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: alttext-ai-automation
+description: "Automate Alttext AI tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Alttext AI Automation via Rube MCP
+
+Automate Alttext AI operations through Composio's Alttext AI toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/alttext_ai](https://composio.dev/toolkits/alttext_ai)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Alttext AI connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `alttext_ai`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `alttext_ai`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Alttext AI operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Alttext AI task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["alttext_ai"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Alttext AI-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `alttext_ai` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

amara-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: amara-automation
+description: "Automate Amara tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Amara Automation via Rube MCP
+
+Automate Amara operations through Composio's Amara toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/amara](https://composio.dev/toolkits/amara)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Amara connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `amara`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `amara`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Amara operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Amara task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["amara"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Amara-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `amara` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

amazon-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: amazon-automation
+description: "Automate Amazon tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Amazon Automation via Rube MCP
+
+Automate Amazon operations through Composio's Amazon toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/amazon](https://composio.dev/toolkits/amazon)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Amazon connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `amazon`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `amazon`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Amazon operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Amazon task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["amazon"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Amazon-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `amazon` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

ambee-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: ambee-automation
+description: "Automate Ambee tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Ambee Automation via Rube MCP
+
+Automate Ambee operations through Composio's Ambee toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/ambee](https://composio.dev/toolkits/ambee)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Ambee connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ambee`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `ambee`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Ambee operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Ambee task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["ambee"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Ambee-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ambee` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

ambient-weather-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: ambient-weather-automation
+description: "Automate Ambient Weather tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Ambient Weather Automation via Rube MCP
+
+Automate Ambient Weather operations through Composio's Ambient Weather toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/ambient_weather](https://composio.dev/toolkits/ambient_weather)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Ambient Weather connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ambient_weather`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `ambient_weather`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Ambient Weather operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Ambient Weather task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["ambient_weather"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Ambient Weather-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ambient_weather` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

amcards-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: amcards-automation
+description: "Automate Amcards tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Amcards Automation via Rube MCP
+
+Automate Amcards operations through Composio's Amcards toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/amcards](https://composio.dev/toolkits/amcards)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Amcards connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `amcards`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `amcards`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Amcards operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Amcards task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["amcards"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Amcards-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `amcards` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

amplitude-automation/SKILL.md

@@ -9,6 +9,8 @@ requires:
 
 Automate Amplitude product analytics through Composio's Amplitude toolkit via Rube MCP.
 
+**Toolkit docs**: [composio.dev/toolkits/amplitude](https://composio.dev/toolkits/amplitude)
+
 ## Prerequisites
 
 - Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
@@ -214,3 +216,6 @@ For cohort membership updates:
 | Update cohort members | AMPLITUDE_UPDATE_COHORT_MEMBERSHIP | cohort_id, memberships |
 | Check cohort status | AMPLITUDE_CHECK_COHORT_STATUS | request_id |
 | List event categories | AMPLITUDE_GET_EVENT_CATEGORIES | (none) |
+
+---
+*Powered by [Composio](https://composio.dev)*

anchor-browser-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: anchor-browser-automation
+description: "Automate Anchor Browser tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Anchor Browser Automation via Rube MCP
+
+Automate Anchor Browser operations through Composio's Anchor Browser toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/anchor_browser](https://composio.dev/toolkits/anchor_browser)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Anchor Browser connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `anchor_browser`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `anchor_browser`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Anchor Browser operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Anchor Browser task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["anchor_browser"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Anchor Browser-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `anchor_browser` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

anonyflow-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: anonyflow-automation
+description: "Automate Anonyflow tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Anonyflow Automation via Rube MCP
+
+Automate Anonyflow operations through Composio's Anonyflow toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/anonyflow](https://composio.dev/toolkits/anonyflow)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Anonyflow connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `anonyflow`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `anonyflow`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Anonyflow operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Anonyflow task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["anonyflow"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Anonyflow-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `anonyflow` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

anthropic-administrator-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: anthropic-administrator-automation
+description: "Automate Anthropic Admin tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Anthropic Admin Automation via Rube MCP
+
+Automate Anthropic Admin operations through Composio's Anthropic Admin toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/anthropic_administrator](https://composio.dev/toolkits/anthropic_administrator)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Anthropic Admin connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `anthropic_administrator`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `anthropic_administrator`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Anthropic Admin operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Anthropic Admin task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["anthropic_administrator"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Anthropic Admin-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `anthropic_administrator` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

anthropic_administrator-automation/SKILL.md

@@ -0,0 +1,110 @@
+---
+name: anthropic_administrator-automation
+description: "Automate Anthropic Admin tasks via Rube MCP (Composio): API keys, usage, workspaces, and organization management. Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Anthropic Admin Automation via Rube MCP
+
+Automate Anthropic Admin operations through Composio's Anthropic Admin toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/anthropic_administrator](https://composio.dev/toolkits/anthropic_administrator)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Anthropic Admin connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `anthropic_administrator`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `anthropic_administrator`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS: queries=[{"use_case": "API keys, usage, workspaces, and organization management", "known_fields": ""}]
+```
+
+This returns:
+- Available tool slugs for Anthropic Admin
+- Recommended execution plan steps
+- Known pitfalls and edge cases
+- Input schemas for each tool
+
+## Core Workflows
+
+### 1. Discover Available Anthropic Admin Tools
+
+```
+RUBE_SEARCH_TOOLS:
+  queries:
+    - use_case: "list all available Anthropic Admin tools and capabilities"
+```
+
+Review the returned tools, their descriptions, and input schemas before proceeding.
+
+### 2. Execute Anthropic Admin Operations
+
+After discovering tools, execute them via:
+
+```
+RUBE_MULTI_EXECUTE_TOOL:
+  tools:
+    - tool_slug: "<discovered_tool_slug>"
+      arguments: {<schema-compliant arguments>}
+  memory: {}
+  sync_response_to_workbench: false
+```
+
+### 3. Multi-Step Workflows
+
+For complex workflows involving multiple Anthropic Admin operations:
+
+1. Search for all relevant tools: `RUBE_SEARCH_TOOLS` with specific use case
+2. Execute prerequisite steps first (e.g., fetch before update)
+3. Pass data between steps using tool responses
+4. Use `RUBE_REMOTE_WORKBENCH` for bulk operations or data processing
+
+## Common Patterns
+
+### Search Before Action
+Always search for existing resources before creating new ones to avoid duplicates.
+
+### Pagination
+Many list operations support pagination. Check responses for `next_cursor` or `page_token` and continue fetching until exhausted.
+
+### Error Handling
+- Check tool responses for errors before proceeding
+- If a tool fails, verify the connection is still ACTIVE
+- Re-authenticate via `RUBE_MANAGE_CONNECTIONS` if connection expired
+
+### Batch Operations
+For bulk operations, use `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` in a loop with `ThreadPoolExecutor` for parallel execution.
+
+## Known Pitfalls
+
+- **Always search tools first**: Tool schemas and available operations may change. Never hardcode tool slugs without first discovering them via `RUBE_SEARCH_TOOLS`.
+- **Check connection status**: Ensure the Anthropic Admin connection is ACTIVE before executing any tools. Expired OAuth tokens require re-authentication.
+- **Respect rate limits**: If you receive rate limit errors, reduce request frequency and implement backoff.
+- **Validate schemas**: Always pass strictly schema-compliant arguments. Use `RUBE_GET_TOOL_SCHEMAS` to load full input schemas when `schemaRef` is returned instead of `input_schema`.
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Anthropic Admin-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `anthropic_administrator` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+> **Toolkit docs**: [composio.dev/toolkits/anthropic_administrator](https://composio.dev/toolkits/anthropic_administrator)

apaleo-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: apaleo-automation
+description: "Automate Apaleo tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Apaleo Automation via Rube MCP
+
+Automate Apaleo operations through Composio's Apaleo toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/apaleo](https://composio.dev/toolkits/apaleo)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Apaleo connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apaleo`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `apaleo`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Apaleo operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Apaleo task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["apaleo"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Apaleo-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apaleo` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

apex27-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: apex27-automation
+description: "Automate Apex27 tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Apex27 Automation via Rube MCP
+
+Automate Apex27 operations through Composio's Apex27 toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/apex27](https://composio.dev/toolkits/apex27)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Apex27 connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apex27`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `apex27`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Apex27 operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Apex27 task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["apex27"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Apex27-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apex27` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

api-bible-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: api-bible-automation
+description: "Automate API Bible tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# API Bible Automation via Rube MCP
+
+Automate API Bible operations through Composio's API Bible toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/api_bible](https://composio.dev/toolkits/api_bible)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active API Bible connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `api_bible`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `api_bible`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "API Bible operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific API Bible task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["api_bible"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with API Bible-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `api_bible` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

api-labz-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: api-labz-automation
+description: "Automate API Labz tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# API Labz Automation via Rube MCP
+
+Automate API Labz operations through Composio's API Labz toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/api_labz](https://composio.dev/toolkits/api_labz)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active API Labz connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `api_labz`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `api_labz`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "API Labz operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific API Labz task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["api_labz"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with API Labz-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `api_labz` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

api-ninjas-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: api-ninjas-automation
+description: "Automate API Ninjas tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# API Ninjas Automation via Rube MCP
+
+Automate API Ninjas operations through Composio's API Ninjas toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/api_ninjas](https://composio.dev/toolkits/api_ninjas)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active API Ninjas connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `api_ninjas`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `api_ninjas`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "API Ninjas operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific API Ninjas task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["api_ninjas"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with API Ninjas-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `api_ninjas` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

api-sports-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: api-sports-automation
+description: "Automate API Sports tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# API Sports Automation via Rube MCP
+
+Automate API Sports operations through Composio's API Sports toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/api_sports](https://composio.dev/toolkits/api_sports)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active API Sports connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `api_sports`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `api_sports`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "API Sports operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific API Sports task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["api_sports"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with API Sports-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `api_sports` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

api2pdf-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: api2pdf-automation
+description: "Automate Api2pdf tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Api2pdf Automation via Rube MCP
+
+Automate Api2pdf operations through Composio's Api2pdf toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/api2pdf](https://composio.dev/toolkits/api2pdf)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Api2pdf connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `api2pdf`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `api2pdf`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Api2pdf operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Api2pdf task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["api2pdf"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Api2pdf-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `api2pdf` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

apiflash-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: apiflash-automation
+description: "Automate Apiflash tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Apiflash Automation via Rube MCP
+
+Automate Apiflash operations through Composio's Apiflash toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/apiflash](https://composio.dev/toolkits/apiflash)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Apiflash connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apiflash`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `apiflash`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Apiflash operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Apiflash task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["apiflash"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Apiflash-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apiflash` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

apify-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: apify-automation
+description: "Automate Apify tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Apify Automation via Rube MCP
+
+Automate Apify operations through Composio's Apify toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/apify](https://composio.dev/toolkits/apify)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Apify connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apify`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `apify`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Apify operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Apify task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["apify"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Apify-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apify` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

apilio-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: apilio-automation
+description: "Automate Apilio tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Apilio Automation via Rube MCP
+
+Automate Apilio operations through Composio's Apilio toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/apilio](https://composio.dev/toolkits/apilio)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Apilio connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apilio`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `apilio`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Apilio operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Apilio task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["apilio"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Apilio-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apilio` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

apipie-ai-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: apipie-ai-automation
+description: "Automate Apipie AI tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Apipie AI Automation via Rube MCP
+
+Automate Apipie AI operations through Composio's Apipie AI toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/apipie_ai](https://composio.dev/toolkits/apipie_ai)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Apipie AI connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apipie_ai`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `apipie_ai`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Apipie AI operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Apipie AI task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["apipie_ai"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Apipie AI-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apipie_ai` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

apitemplate-io-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: apitemplate-io-automation
+description: "Automate Apitemplate IO tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Apitemplate IO Automation via Rube MCP
+
+Automate Apitemplate IO operations through Composio's Apitemplate IO toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/apitemplate_io](https://composio.dev/toolkits/apitemplate_io)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Apitemplate IO connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apitemplate_io`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `apitemplate_io`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Apitemplate IO operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Apitemplate IO task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["apitemplate_io"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Apitemplate IO-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apitemplate_io` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

apiverve-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: apiverve-automation
+description: "Automate Apiverve tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Apiverve Automation via Rube MCP
+
+Automate Apiverve operations through Composio's Apiverve toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/apiverve](https://composio.dev/toolkits/apiverve)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Apiverve connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apiverve`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `apiverve`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Apiverve operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Apiverve task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["apiverve"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Apiverve-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apiverve` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

apollo-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: apollo-automation
+description: "Automate Apollo tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Apollo Automation via Rube MCP
+
+Automate Apollo operations through Composio's Apollo toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/apollo](https://composio.dev/toolkits/apollo)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Apollo connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apollo`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `apollo`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Apollo operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Apollo task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["apollo"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Apollo-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apollo` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

appcircle-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: appcircle-automation
+description: "Automate Appcircle tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Appcircle Automation via Rube MCP
+
+Automate Appcircle operations through Composio's Appcircle toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/appcircle](https://composio.dev/toolkits/appcircle)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Appcircle connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `appcircle`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `appcircle`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Appcircle operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Appcircle task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["appcircle"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Appcircle-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `appcircle` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

appdrag-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: appdrag-automation
+description: "Automate Appdrag tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Appdrag Automation via Rube MCP
+
+Automate Appdrag operations through Composio's Appdrag toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/appdrag](https://composio.dev/toolkits/appdrag)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Appdrag connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `appdrag`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `appdrag`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Appdrag operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Appdrag task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["appdrag"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Appdrag-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `appdrag` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

appointo-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: appointo-automation
+description: "Automate Appointo tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Appointo Automation via Rube MCP
+
+Automate Appointo operations through Composio's Appointo toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/appointo](https://composio.dev/toolkits/appointo)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Appointo connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `appointo`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `appointo`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Appointo operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Appointo task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["appointo"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Appointo-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `appointo` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

appsflyer-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: appsflyer-automation
+description: "Automate Appsflyer tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Appsflyer Automation via Rube MCP
+
+Automate Appsflyer operations through Composio's Appsflyer toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/appsflyer](https://composio.dev/toolkits/appsflyer)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Appsflyer connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `appsflyer`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `appsflyer`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Appsflyer operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Appsflyer task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["appsflyer"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Appsflyer-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `appsflyer` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

appveyor-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: appveyor-automation
+description: "Automate Appveyor tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Appveyor Automation via Rube MCP
+
+Automate Appveyor operations through Composio's Appveyor toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/appveyor](https://composio.dev/toolkits/appveyor)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Appveyor connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `appveyor`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `appveyor`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Appveyor operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Appveyor task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["appveyor"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Appveyor-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `appveyor` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

aryn-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: aryn-automation
+description: "Automate Aryn tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Aryn Automation via Rube MCP
+
+Automate Aryn operations through Composio's Aryn toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/aryn](https://composio.dev/toolkits/aryn)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Aryn connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `aryn`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `aryn`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Aryn operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Aryn task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["aryn"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Aryn-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `aryn` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

asana-automation/SKILL.md

@@ -9,6 +9,8 @@ requires:
 
 Automate Asana operations through Composio's Asana toolkit via Rube MCP.
 
+**Toolkit docs**: [composio.dev/toolkits/asana](https://composio.dev/toolkits/asana)
+
 ## Prerequisites
 
 - Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
@@ -169,3 +171,6 @@ Automate Asana operations through Composio's Asana toolkit via Rube MCP.
 | Workspace users | ASANA_GET_USERS_FOR_WORKSPACE | workspace_gid |
 | Current user | ASANA_GET_CURRENT_USER | (none) |
 | Parallel requests | ASANA_SUBMIT_PARALLEL_REQUESTS | actions |
+
+---
+*Powered by [Composio](https://composio.dev)*

ascora-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: ascora-automation
+description: "Automate Ascora tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Ascora Automation via Rube MCP
+
+Automate Ascora operations through Composio's Ascora toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/ascora](https://composio.dev/toolkits/ascora)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Ascora connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ascora`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `ascora`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Ascora operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Ascora task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["ascora"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Ascora-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ascora` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

ashby-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: ashby-automation
+description: "Automate Ashby tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Ashby Automation via Rube MCP
+
+Automate Ashby operations through Composio's Ashby toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/ashby](https://composio.dev/toolkits/ashby)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Ashby connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ashby`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `ashby`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Ashby operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Ashby task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["ashby"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Ashby-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ashby` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

asin-data-api-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: asin-data-api-automation
+description: "Automate Asin Data API tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Asin Data API Automation via Rube MCP
+
+Automate Asin Data API operations through Composio's Asin Data API toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/asin_data_api](https://composio.dev/toolkits/asin_data_api)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Asin Data API connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `asin_data_api`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `asin_data_api`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Asin Data API operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Asin Data API task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["asin_data_api"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Asin Data API-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `asin_data_api` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

astica-ai-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: astica-ai-automation
+description: "Automate Astica AI tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Astica AI Automation via Rube MCP
+
+Automate Astica AI operations through Composio's Astica AI toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/astica_ai](https://composio.dev/toolkits/astica_ai)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Astica AI connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `astica_ai`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `astica_ai`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Astica AI operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Astica AI task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["astica_ai"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Astica AI-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `astica_ai` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

async-interview-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: async-interview-automation
+description: "Automate Async Interview tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Async Interview Automation via Rube MCP
+
+Automate Async Interview operations through Composio's Async Interview toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/async_interview](https://composio.dev/toolkits/async_interview)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Async Interview connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `async_interview`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `async_interview`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Async Interview operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Async Interview task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["async_interview"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Async Interview-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `async_interview` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

atlassian-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: atlassian-automation
+description: "Automate Atlassian tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Atlassian Automation via Rube MCP
+
+Automate Atlassian operations through Composio's Atlassian toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/atlassian](https://composio.dev/toolkits/atlassian)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Atlassian connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `atlassian`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `atlassian`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Atlassian operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Atlassian task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["atlassian"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Atlassian-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `atlassian` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

attio-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: attio-automation
+description: "Automate Attio tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Attio Automation via Rube MCP
+
+Automate Attio operations through Composio's Attio toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/attio](https://composio.dev/toolkits/attio)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Attio connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `attio`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `attio`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Attio operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Attio task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["attio"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Attio-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `attio` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

auth0-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: auth0-automation
+description: "Automate Auth0 tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Auth0 Automation via Rube MCP
+
+Automate Auth0 operations through Composio's Auth0 toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/auth0](https://composio.dev/toolkits/auth0)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Auth0 connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `auth0`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `auth0`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Auth0 operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Auth0 task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["auth0"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Auth0-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `auth0` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

autobound-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: autobound-automation
+description: "Automate Autobound tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Autobound Automation via Rube MCP
+
+Automate Autobound operations through Composio's Autobound toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/autobound](https://composio.dev/toolkits/autobound)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Autobound connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `autobound`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `autobound`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Autobound operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Autobound task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["autobound"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Autobound-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `autobound` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

autom-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: autom-automation
+description: "Automate Autom tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Autom Automation via Rube MCP
+
+Automate Autom operations through Composio's Autom toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/autom](https://composio.dev/toolkits/autom)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Autom connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `autom`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `autom`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Autom operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Autom task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["autom"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Autom-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `autom` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

axonaut-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: axonaut-automation
+description: "Automate Axonaut tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Axonaut Automation via Rube MCP
+
+Automate Axonaut operations through Composio's Axonaut toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/axonaut](https://composio.dev/toolkits/axonaut)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Axonaut connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `axonaut`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `axonaut`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Axonaut operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Axonaut task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["axonaut"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Axonaut-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `axonaut` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

ayrshare-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: ayrshare-automation
+description: "Automate Ayrshare tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Ayrshare Automation via Rube MCP
+
+Automate Ayrshare operations through Composio's Ayrshare toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/ayrshare](https://composio.dev/toolkits/ayrshare)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Ayrshare connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ayrshare`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `ayrshare`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Ayrshare operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Ayrshare task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["ayrshare"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Ayrshare-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ayrshare` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

backendless-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: backendless-automation
+description: "Automate Backendless tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Backendless Automation via Rube MCP
+
+Automate Backendless operations through Composio's Backendless toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/backendless](https://composio.dev/toolkits/backendless)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Backendless connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `backendless`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `backendless`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Backendless operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Backendless task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["backendless"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Backendless-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `backendless` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

bamboohr-automation/SKILL.md

@@ -9,6 +9,8 @@ requires:
 
 Automate BambooHR human resources operations through Composio's BambooHR toolkit via Rube MCP.
 
+**Toolkit docs**: [composio.dev/toolkits/bamboohr](https://composio.dev/toolkits/bamboohr)
+
 ## Prerequisites
 
 - Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
@@ -218,3 +220,6 @@ For keeping external systems in sync with BambooHR:
 | Update employee | BAMBOOHR_UPDATE_EMPLOYEE | id, (field updates) |
 | List dependents | BAMBOOHR_DEPENDENTS_GET_ALL | employeeId |
 | Benefit coverages | BAMBOOHR_BENEFIT_GET_COVERAGES | (check schema) |
+
+---
+*Powered by [Composio](https://composio.dev)*

bannerbear-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: bannerbear-automation
+description: "Automate Bannerbear tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Bannerbear Automation via Rube MCP
+
+Automate Bannerbear operations through Composio's Bannerbear toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/bannerbear](https://composio.dev/toolkits/bannerbear)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Bannerbear connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `bannerbear`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `bannerbear`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Bannerbear operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Bannerbear task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["bannerbear"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Bannerbear-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `bannerbear` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

bart-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: bart-automation
+description: "Automate Bart tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Bart Automation via Rube MCP
+
+Automate Bart operations through Composio's Bart toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/bart](https://composio.dev/toolkits/bart)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Bart connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `bart`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `bart`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Bart operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Bart task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["bart"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Bart-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `bart` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

basecamp-automation/SKILL.md

@@ -9,6 +9,8 @@ requires:
 
 Automate Basecamp operations including project management, to-do list creation, task management, message board posting, people management, and to-do group organization through Composio's Basecamp toolkit.
 
+**Toolkit docs**: [composio.dev/toolkits/basecamp](https://composio.dev/toolkits/basecamp)
+
 ## Prerequisites
 
 - Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
@@ -232,3 +234,6 @@ Basecamp uses page-based pagination on list endpoints:
 | List all people | `BASECAMP_GET_PEOPLE` | (none) |
 | List project people | `BASECAMP_LIST_PROJECT_PEOPLE` | `project_id` |
 | Manage access | `BASECAMP_PUT_PROJECTS_PEOPLE_USERS` | `project_id`, `grant`, `revoke`, `create` |
+
+---
+*Powered by [Composio](https://composio.dev)*

baselinker-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: baselinker-automation
+description: "Automate Baselinker tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Baselinker Automation via Rube MCP
+
+Automate Baselinker operations through Composio's Baselinker toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/baselinker](https://composio.dev/toolkits/baselinker)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Baselinker connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `baselinker`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `baselinker`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Baselinker operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Baselinker task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["baselinker"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Baselinker-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `baselinker` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

baserow-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: baserow-automation
+description: "Automate Baserow tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Baserow Automation via Rube MCP
+
+Automate Baserow operations through Composio's Baserow toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/baserow](https://composio.dev/toolkits/baserow)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Baserow connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `baserow`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `baserow`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Baserow operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Baserow task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["baserow"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Baserow-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `baserow` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

basin-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: basin-automation
+description: "Automate Basin tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Basin Automation via Rube MCP
+
+Automate Basin operations through Composio's Basin toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/basin](https://composio.dev/toolkits/basin)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Basin connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `basin`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `basin`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Basin operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Basin task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["basin"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Basin-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `basin` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

battlenet-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: battlenet-automation
+description: "Automate Battlenet tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Battlenet Automation via Rube MCP
+
+Automate Battlenet operations through Composio's Battlenet toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/battlenet](https://composio.dev/toolkits/battlenet)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Battlenet connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `battlenet`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `battlenet`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Battlenet operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Battlenet task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["battlenet"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Battlenet-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `battlenet` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

beaconchain-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: beaconchain-automation
+description: "Automate Beaconchain tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Beaconchain Automation via Rube MCP
+
+Automate Beaconchain operations through Composio's Beaconchain toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/beaconchain](https://composio.dev/toolkits/beaconchain)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Beaconchain connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `beaconchain`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `beaconchain`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Beaconchain operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Beaconchain task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["beaconchain"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Beaconchain-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `beaconchain` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

beaconstac-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: beaconstac-automation
+description: "Automate Beaconstac tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Beaconstac Automation via Rube MCP
+
+Automate Beaconstac operations through Composio's Beaconstac toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/beaconstac](https://composio.dev/toolkits/beaconstac)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Beaconstac connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `beaconstac`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `beaconstac`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Beaconstac operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Beaconstac task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["beaconstac"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Beaconstac-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `beaconstac` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

beamer-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: beamer-automation
+description: "Automate Beamer tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Beamer Automation via Rube MCP
+
+Automate Beamer operations through Composio's Beamer toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/beamer](https://composio.dev/toolkits/beamer)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Beamer connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `beamer`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `beamer`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Beamer operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Beamer task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["beamer"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Beamer-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `beamer` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

beeminder-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: beeminder-automation
+description: "Automate Beeminder tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Beeminder Automation via Rube MCP
+
+Automate Beeminder operations through Composio's Beeminder toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/beeminder](https://composio.dev/toolkits/beeminder)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Beeminder connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `beeminder`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `beeminder`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Beeminder operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Beeminder task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["beeminder"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Beeminder-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `beeminder` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

bench-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: bench-automation
+description: "Automate Bench tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Bench Automation via Rube MCP
+
+Automate Bench operations through Composio's Bench toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/bench](https://composio.dev/toolkits/bench)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Bench connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `bench`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `bench`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Bench operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Bench task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["bench"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Bench-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `bench` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

benchmark-email-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: benchmark-email-automation
+description: "Automate Benchmark Email tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Benchmark Email Automation via Rube MCP
+
+Automate Benchmark Email operations through Composio's Benchmark Email toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/benchmark_email](https://composio.dev/toolkits/benchmark_email)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Benchmark Email connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `benchmark_email`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `benchmark_email`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Benchmark Email operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Benchmark Email task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["benchmark_email"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Benchmark Email-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `benchmark_email` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

benzinga-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: benzinga-automation
+description: "Automate Benzinga tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Benzinga Automation via Rube MCP
+
+Automate Benzinga operations through Composio's Benzinga toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/benzinga](https://composio.dev/toolkits/benzinga)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Benzinga connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `benzinga`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `benzinga`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Benzinga operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Benzinga task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["benzinga"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Benzinga-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `benzinga` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

bestbuy-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: bestbuy-automation
+description: "Automate Bestbuy tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Bestbuy Automation via Rube MCP
+
+Automate Bestbuy operations through Composio's Bestbuy toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/bestbuy](https://composio.dev/toolkits/bestbuy)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Bestbuy connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `bestbuy`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `bestbuy`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Bestbuy operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Bestbuy task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["bestbuy"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Bestbuy-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `bestbuy` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

better-proposals-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: better-proposals-automation
+description: "Automate Better Proposals tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Better Proposals Automation via Rube MCP
+
+Automate Better Proposals operations through Composio's Better Proposals toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/better_proposals](https://composio.dev/toolkits/better_proposals)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Better Proposals connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `better_proposals`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `better_proposals`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Better Proposals operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Better Proposals task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["better_proposals"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Better Proposals-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `better_proposals` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

better-stack-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: better-stack-automation
+description: "Automate Better Stack tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Better Stack Automation via Rube MCP
+
+Automate Better Stack operations through Composio's Better Stack toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/better_stack](https://composio.dev/toolkits/better_stack)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Better Stack connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `better_stack`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `better_stack`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Better Stack operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Better Stack task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["better_stack"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Better Stack-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `better_stack` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

bidsketch-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: bidsketch-automation
+description: "Automate Bidsketch tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Bidsketch Automation via Rube MCP
+
+Automate Bidsketch operations through Composio's Bidsketch toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/bidsketch](https://composio.dev/toolkits/bidsketch)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Bidsketch connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `bidsketch`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `bidsketch`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Bidsketch operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Bidsketch task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["bidsketch"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Bidsketch-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `bidsketch` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*

big-data-cloud-automation/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: big-data-cloud-automation
+description: "Automate Big Data Cloud tasks via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Big Data Cloud Automation via Rube MCP
+
+Automate Big Data Cloud operations through Composio's Big Data Cloud toolkit via Rube MCP.
+
+**Toolkit docs**: [composio.dev/toolkits/big_data_cloud](https://composio.dev/toolkits/big_data_cloud)
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Big Data Cloud connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `big_data_cloud`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `big_data_cloud`
+3. If connection is not ACTIVE, follow the returned auth link to complete setup
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Tool Discovery
+
+Always discover available tools before executing workflows:
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "Big Data Cloud operations", known_fields: ""}]
+session: {generate_id: true}
+```
+
+This returns available tool slugs, input schemas, recommended execution plans, and known pitfalls.
+
+## Core Workflow Pattern
+
+### Step 1: Discover Available Tools
+
+```
+RUBE_SEARCH_TOOLS
+queries: [{use_case: "your specific Big Data Cloud task"}]
+session: {id: "existing_session_id"}
+```
+
+### Step 2: Check Connection
+
+```
+RUBE_MANAGE_CONNECTIONS
+toolkits: ["big_data_cloud"]
+session_id: "your_session_id"
+```
+
+### Step 3: Execute Tools
+
+```
+RUBE_MULTI_EXECUTE_TOOL
+tools: [{
+  tool_slug: "TOOL_SLUG_FROM_SEARCH",
+  arguments: {/* schema-compliant args from search results */}
+}]
+memory: {}
+session_id: "your_session_id"
+```
+
+## Known Pitfalls
+
+- **Always search first**: Tool schemas change. Never hardcode tool slugs or arguments without calling `RUBE_SEARCH_TOOLS`
+- **Check connection**: Verify `RUBE_MANAGE_CONNECTIONS` shows ACTIVE status before executing tools
+- **Schema compliance**: Use exact field names and types from the search results
+- **Memory parameter**: Always include `memory` in `RUBE_MULTI_EXECUTE_TOOL` calls, even if empty (`{}`)
+- **Session reuse**: Reuse session IDs within a workflow. Generate new ones for new workflows
+- **Pagination**: Check responses for pagination tokens and continue fetching until complete
+
+## Quick Reference
+
+| Operation | Approach |
+|-----------|----------|
+| Find tools | `RUBE_SEARCH_TOOLS` with Big Data Cloud-specific use case |
+| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `big_data_cloud` |
+| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
+| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
+| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |
+
+---
+*Powered by [Composio](https://composio.dev)*