Do I need API keys to use Kickbox via Rube MCP?

No API keys are required for the MCP setup itself. You authenticate and connect through RUBE_MANAGE_CONNECTIONS and the provided endpoint, then use tool schemas discovered via RUBE_SEARCH_TOOLS.

Is it mandatory to call RUBE_SEARCH_TOOLS before every workflow?

Yes. The skill emphasizes always searching for current tool schemas to avoid stale slugs and mismatched arguments.

What happens if tool schemas change during a workflow?

You should re-run RUBE_SEARCH_TOOLS to refresh tool slugs and input schemas, then adjust the RUBE_MULTI_EXECUTE_TOOL call accordingly to maintain compatibility.

kickbox-automation

npx machina-cli add skill ComposioHQ/awesome-claude-skills/kickbox-automation --openclaw

Files (1)

SKILL.md

2.9 KB

Kickbox Automation via Rube MCP

Automate Kickbox operations through Composio's Kickbox toolkit via Rube MCP.

Toolkit docs: composio.dev/toolkits/kickbox

Prerequisites

Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
Active Kickbox connection via RUBE_MANAGE_CONNECTIONS with toolkit kickbox
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.

Verify Rube MCP is available by confirming RUBE_SEARCH_TOOLS responds
Call RUBE_MANAGE_CONNECTIONS with toolkit kickbox
If connection is not ACTIVE, follow the returned auth link to complete setup
Confirm connection status shows ACTIVE before running any workflows

Tool Discovery

Always discover available tools before executing workflows:

RUBE_SEARCH_TOOLS
queries: [{use_case: "Kickbox 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 Kickbox task"}]
session: {id: "existing_session_id"}

Step 2: Check Connection

RUBE_MANAGE_CONNECTIONS
toolkits: ["kickbox"]
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 Kickbox-specific use case
Connect	`RUBE_MANAGE_CONNECTIONS` with toolkit `kickbox`
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

Source

git clone https://github.com/ComposioHQ/awesome-claude-skills/blob/master/composio-skills/kickbox-automation/SKILL.mdView on GitHub

Overview

Kickbox Automation via Rube MCP lets you automate Kickbox operations through Composio’s toolkit. It emphasizes querying current tool schemas first with RUBE_SEARCH_TOOLS to ensure up-to-date integration. Set up involves connecting Rube MCP, validating ACTIVE status, discovering tools, and then executing workflows against discovered tools.

How This Skill Works

The workflow starts by calling RUBE_SEARCH_TOOLS to fetch available Kickbox tools and their input schemas. Next, you verify the Kickbox connection with RUBE_MANAGE_CONNECTIONS and ensure the toolkit is ACTIVE. Finally, you execute the chosen tool using RUBE_MULTI_EXECUTE_TOOL with the discovered tool_slug, proper arguments, and memory (even if empty).

When to Use It

When you need to automate recurring Kickbox operations via MCP.
When starting a workflow, first call RUBE_SEARCH_TOOLS to obtain current tool schemas and slugs.
When establishing or verifying a Kickbox connection to ensure ACTIVE status before execution.
When executing a discovered tool using RUBE_MULTI_EXECUTE_TOOL with the correct arguments.
When tool schemas change or you need to handle pagination tokens during tool discovery.

Quick Start

Step 1: RUBE_SEARCH_TOOLS with use_case: "Kickbox operations" to list available tools and their schemas.
Step 2: RUBE_MANAGE_CONNECTIONS for toolkit: "kickbox" and confirm the status is ACTIVE.
Step 3: RUBE_MULTI_EXECUTE_TOOL with tool_slug from search results, proper arguments, memory: {} and session_id from the discovery step.

Best Practices

Always search first: tool schemas change; never hardcode slugs or arguments without RUBE_SEARCH_TOOLS.
Check connection: ensure RUBE_MANAGE_CONNECTIONS shows ACTIVE before running tools.
Use exact field names and types from the search results (schema compliance).
Always include memory in RUBE_MULTI_EXECUTE_TOOL calls, even if empty ({}).
Reuse session IDs within a workflow and generate new ones for separate workflows.

Example Use Cases

Discover Kickbox tools with RUBE_SEARCH_TOOLS, then execute a domain verification task using the returned tool_slug.
Connect to Kickbox via RUBE_MANAGE_CONNECTIONS and verify ACTIVE before starting a batch of checks.
Run multiple Kickbox operations in sequence using RUBE_MULTI_EXECUTE_TOOL with memory and session_id from the discovery step.
Fetch updated tool schemas after a platform update and adapt the workflow without hardcoding slugs.
Handle paginated tool lists by continuing to fetch until no tokens remain and then execute the selected tool.

Frequently Asked Questions

Add this skill to your agents