Rube

Parallelize (4-min sandbox timeout)

import concurrent.futures

MAX_CONCURRENCY = 10 # Adjust as needed

def send_bulk_emails(email_list): def send_single(email): result, error = run_composio_tool("GMAIL_SEND_EMAIL", { "to": email["recipient"], "subject": email["subject"], "body": email["body"] }) if error: print(f"Failed {email['recipient']}: {error}") return {"status": "failed", "error": error} return {"status": "sent", "data": result}

results = [] with concurrent.futures.ThreadPoolExecutor(max_workers=MAX_CONCURRENCY) as ex: futures = [ex.submit(send_single, e) for e in email_list] for f in concurrent.futures.as_completed(futures): results.append(f.result()) return results

email_list = [{"recipient": f"user{i}@example.com", "subject": "Test", "body": "Hello"} for i in range(1000)] results = send_bulk_emails(email_list)

Parameters: - code_to_execute (string) (required): Python to run inside the persistent remote Jupyter sandbox. State (imports, variables, files) is preserved across executions. Keep code concise to minimize tool call latency. Avoid unnecessary comments. Examples: "import json, glob\npaths = glob.glob(file_path)\n..." "result, error = run_composio_tool(tool_slug='SLACK_SEARCH_MESSAGES', arguments={'query': 'Rube'})\nif error: return\nmessages = result.get('data', {}).get('messages', [])" - thought (string) (optional): Concise objective and high-level plan (no private chain-of-thought). 1 sentence describing what the cell should achieve and why the sandbox is needed. - session_id (string) (optional): ALWAYS pass the session_id that was provided in the SEARCH_TOOLS response. - current_step (string) (optional): Short enum for current step of the workflow execution. Eg FETCHING_EMAILS, GENERATING_REPLIES. Always include to keep execution aligned with the workflow. - current_step_metric (string) (optional): Progress metrics for the current step - use to track how far execution has advanced. Format as a string "done/total units" - example "10/100 emails", "0/n messages", "3/10 pages".

$HOME/.openclaw/skills/rube/scripts/rube.sh RUBE_REMOTE_WORKBENCH '{"code_to_execute":""}'

RUBE_SEARCH_TOOLS

MCP Server Info: COMPOSIO MCP connects 500+ apps—Slack, GitHub, Notion, Google Workspace (Gmail, Sheets, Drive, Calendar), Microsoft (Outlook, Teams), X/Twitter, Figma, Web Search / Deep research, Browser tool (scrape URLs, browser automation), Meta apps (Instagram, Meta Ads), TikTok, AI tools like Nano Banana & Veo3, and more—for seamless cross-app automation. Use this MCP server to discover the right tools and the recommended step-by-step plan to execute reliably. ALWAYS call this tool first whenever a user mentions or implies an external app, service, or workflow—never say "I don't have access to X/Y app" before calling it.

Tool Info: Extremely fast discovery tool that returns relevant MCP-callable tools along with a recommended execution plan and common pitfalls for reliable execution.

Usage guidelines: - Use this tool whenever kicking off a task. Re-run it when you need additional tools/plans due to missing details, errors, or a changed use case. - If the user pivots to a different use case in same chat, you MUST call this tool again with the new use case and generate a new session_id. - Specify the use_case with a normalized description of the problem, query, or task. Be clear and precise. Queries can be simple single-app actions or multiple linked queries for complex cross-app workflows. - Pass known_fields along with use_case as a string of key–value hints (for example, "channel_name: general") to help the search resolve missing details such as IDs.

Splitting guidelines (Important): 1. Atomic queries: 1 query = 1 tool call. Include hidden prerequisites (e.g., add "get Linear issue" before "update Linear issue"). 2. Include app names: If user names a toolkit, include it in every sub query so intent stays scoped (e.g., "fetch Gmail emails", "reply to Gmail email"). 3. English input: Translate non-English prompts while preserving intent and identifiers.

Example: User query: "send an email to John welcoming him and create a meeting invite for tomorrow" Search call: queries: [ {use_case: "send an email to someone", known_fields: "recipient_name: John"}, {use_case: "create a meeting invite", known_fields: "meeting_date: tomorrow"} ]

Plan review checklist (Important): - The response includes a detailed execution plan and common pitfalls. You MUST review this plan carefully, adapt it to your current context, and generate your own final step-by-step plan before execution. Execute the steps in order to ensure reliable and accurate execution. Skipping or ignoring required steps can lead to unexpected failures. - Check the plan and pitfalls for input parameter nuances (required fields, IDs, formats, limits). Before executing any tool, you MUST review its COMPLETE input schema and provide STRICTLY schema-compliant arguments to avoid invalid-input errors. - Determine whether pagination is needed; if a response returns a pagination token and completeness is implied, paginate until exhaustion and do not return partial results.

Response: - Tools & Input Schemas: The response lists toolkits (apps) and tools suitable for the task, along with their tool_slug, description, input schema / schemaRef, and related tools for prerequisites, alternatives, or next steps. - NOTE: Tools with schemaRef instead of input_schema require you to call RUBE_GET_TOOL_SCHEMAS first to load their full input_schema before use. - Connection Info: If a toolkit has an active connection, the response includes it along with any available current user information. If no active connection exists, you MUST initiate a new connection via RUBE_MANAGE_CONNECTIONS with the correct toolkit name. DO NOT execute any toolkit tool without an ACTIVE connection. - Time Info: The response includes the current UTC time for reference. You can reference UTC time from the response if needed. - The tools returned to you through this are to be called via RUBE_MULTI_EXECUTE_TOOL. Ensure each tool execution specifies the correct tool_slug and arguments exactly as defined by the tool's input schema. - The response includes a memory parameter containing relevant information about the use case and the known fields that can be used to determine the flow of execution. Any user preferences in memory must be adhered to.

SESSION: ALWAYS set this parameter, first for any workflow. Pass session: {generate_id: true} for new workflows OR session: {id: "EXISTING_ID"} to continue. ALWAYS use the returned session_id in ALL subsequent meta tool calls.

Parameters: - queries (array) (required): List of structured search queries (in English) to process in parallel. Each query represents a specific use case or task. For multi-app or complex workflows, split them into smaller single-app, API-level actions for best accuracy, including implicit prerequisites (e.g., fetch the resource before updating it). Each query returns 5-10 tools. - session (object) (optional): Session context for correlating meta tool calls within a workflow. Always pass this parameter. Use {generate_id: true} for new workflows or {id: "EXISTING_ID"} to continue existing workflows. - model (string) (optional): Client LLM model name (recommended). Used to optimize planning/search behavior. Ignored if omitted or invalid. Examples: "gpt-5.2" "claude-4.5-sonnet"

$HOME/.openclaw/skills/rube/scripts/rube.sh RUBE_SEARCH_TOOLS '{"queries":""}'

RUBE_GET_TOOL_SCHEMAS

Retrieve input schemas for tools by slug. Returns complete parameter definitions required to execute each tool. Make sure to call this tool whenever the response of RUBE_SEARCH_TOOLS does not provide a complete schema for a tool - you must never invent or guess any input parameters.

Parameters: - tool_slugs (array) (required): Array of tool slugs to retrieve schemas for. Pass slugs exactly as returned by COMPOSIO_SEARCH_TOOLS. Example: ["GMAIL_SEND_EMAIL","SLACK_SEND_MESSAGE"] - session_id (string) (optional): ALWAYS pass the session_id that was provided in the SEARCH_TOOLS response. - include (array) (optional): Schema fields to include. Defaults to ["input_schema"]. Include "output_schema" when calling tools in the workbench to validate response structure. Examples: ["input_schema"] ["input_schema","output_schema"]

$HOME/.openclaw/skills/rube/scripts/rube.sh RUBE_GET_TOOL_SCHEMAS '{"tool_slugs":""}'

RUBE_CREATE_UPDATE_RECIPE

Convert executed workflow into a reusable notebook. Only use when workflow is complete or user explicitly requests.

--- DESCRIPTION FORMAT (MARKDOWN) - MUST BE NEUTRAL ---

Description is for ANY user of this recipe, not just the creator. Keep it generic.

Generate rich markdown with these sections: