home / skills / composiohq / awesome-claude-skills / agiled-automation

agiled-automation skill

safe

This skill automates Agiled tasks via Rube MCP, enabling tool discovery, connection checks, and schema-aware execution for streamlined workflows.

npx playbooks add skill composiohq/awesome-claude-skills --skill agiled-automation

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

2.8 KB

---
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)*

Overview

This skill automates Agiled tasks by orchestrating Composio's Agiled toolkit through Rube MCP. It provides a repeatable pattern to discover tools, validate connections, and execute toolkit operations reliably. The skill enforces dynamic discovery of tool schemas so workflows remain resilient to API changes.

How this skill works

The skill first calls RUBE_SEARCH_TOOLS to retrieve available tool slugs, input schemas, and recommended execution plans. It then validates an Agiled connection via RUBE_MANAGE_CONNECTIONS and runs operations using RUBE_MULTI_EXECUTE_TOOL (or RUBE_REMOTE_WORKBENCH for bulk jobs), always supplying the exact schema-compliant arguments and a memory object. Session IDs are reused within workflows and new sessions generated for new flows.

When to use it

Automate routine Agiled actions like creating tasks, syncing contacts, or updating deals
Run multi-step Agiled workflows that require tool discovery and connection validation
Perform bulk operations using Composio tools through Rube MCP
Integrate Agiled automation into agent-driven pipelines or CI workflows
When tool schemas may change frequently and you need dynamic discovery before execution

Best practices

Always run RUBE_SEARCH_TOOLS first to fetch current tool slugs and input schemas
Verify RUBE_MANAGE_CONNECTIONS shows ACTIVE for the agiled toolkit before any execute calls
Use exact field names and types returned by search results; never hardcode argument shapes
Always include a memory parameter in RUBE_MULTI_EXECUTE_TOOL calls, even if empty ({})
Reuse session_id for related workflow steps; generate new session_id for new workflows
Handle pagination tokens in search responses and iterate until results are complete

Example use cases

Create or update Agiled tasks programmatically after discovering the current task creation tool schema
Execute multi-step lead-to-deal workflows: search tools, confirm connection, then run create-contact and create-deal tools
Perform bulk status updates across projects using RUBE_REMOTE_WORKBENCH with run_composio_tool()
Embed Agiled operations inside an agent that adapts to updated tool schemas at runtime
Automate connection setup checks and prompt interactive auth when RUBE_MANAGE_CONNECTIONS reports non-ACTIVE

FAQ

What if RUBE_SEARCH_TOOLS returns a different schema than I expect?

Use the returned schema fields and types for arguments. Do not proceed with hardcoded inputs; adjust your payload to match the discovered schema.

Is an API key required to connect to Rube MCP?

No API key is required for the MCP endpoint; add https://rube.app/mcp to your client configuration and follow the toolkit auth flow via RUBE_MANAGE_CONNECTIONS if needed.