radar-automation
by ComposioHQradar-automation is a Claude skill for Radar workflow automation through Composio Rube MCP. It guides agents to search live Radar tools, verify the active connection, and execute with current schemas.
This skill scores 70/100, which makes it an acceptable but limited directory listing. For directory users, it offers enough concrete MCP setup and workflow guidance to be more useful than a generic prompt for Radar automation, but it is mostly a discovery-and-connection pattern rather than a richly documented set of Radar workflows.
- Clear trigger and scope: it is specifically for automating Radar operations through Composio's Radar toolkit via Rube MCP.
- Provides actionable prerequisites and setup steps, including checking RUBE_SEARCH_TOOLS, using RUBE_MANAGE_CONNECTIONS, and confirming an ACTIVE Radar connection.
- Emphasizes schema discovery before execution, which should help agents avoid stale assumptions when calling Radar tools.
- Relies heavily on live Rube tool discovery rather than bundled Radar-specific schemas, examples, or reference files, so execution details may still require interpretation at runtime.
- No install command or support files are included beyond SKILL.md; adoption depends on having Rube MCP and an active Radar connection configured.
Overview of radar-automation skill
What radar-automation does
radar-automation is a Claude skill for running Radar workflows through Composio’s Rube MCP server. It is not a static Radar API wrapper; its main instruction is to discover the currently available Radar tools with RUBE_SEARCH_TOOLS, verify the Radar connection, and then execute the right MCP tool using the live schema returned by Rube.
Best fit for Workflow Automation users
The radar-automation skill is best for teams that already use Radar and want an AI agent to help with repeatable operational tasks without hardcoding tool names or stale parameters. It fits Workflow Automation use cases where the agent must check connection state, inspect available actions, and adapt to the current Composio toolkit schema before acting.
Main adoption requirement
The key blocker is setup, not prompting. You need Rube MCP connected in your client and an active Radar connection through RUBE_MANAGE_CONNECTIONS with toolkit radar. If RUBE_SEARCH_TOOLS is unavailable, or the Radar connection is not ACTIVE, the skill cannot reliably execute Radar tasks.
Why this is different from a generic prompt
A generic prompt might ask the model to “use Radar,” but it may guess nonexistent tools or outdated fields. radar-automation forces a safer pattern: search tools first, use the returned schemas, check the connection, then run the workflow. That makes it more useful for real automation than a one-off natural-language instruction.
How to Use radar-automation skill
radar-automation install and setup path
Install the skill from the GitHub skill collection, then configure Rube MCP separately:
npx skills add ComposioHQ/awesome-claude-skills --skill radar-automation
In your AI client, add the MCP server endpoint:
https://rube.app/mcp
Then confirm the required MCP tools are available. The skill expects RUBE_SEARCH_TOOLS and RUBE_MANAGE_CONNECTIONS. Use RUBE_MANAGE_CONNECTIONS with toolkit radar; if the connection is not active, complete the returned authorization flow before asking the agent to run Radar operations.
Inputs the skill needs from you
For good radar-automation usage, provide the actual job, the Radar object or workflow area, constraints, and what should happen after tool discovery. Avoid asking “do my Radar task” without context. A stronger prompt includes:
- the specific Radar outcome you want
- any known identifiers, names, filters, or time ranges
- whether the agent may make changes or should only inspect
- how to handle missing fields or ambiguous matches
- whether you want a summary, audit trail, or next-step recommendation
Example:
“Use the radar-automation skill. First search Rube tools for the Radar action needed to review recent events for this account. Check that the Radar connection is active. Do not modify anything unless the discovered tool schema clearly supports the requested action. Summarize the tool used, required fields, returned result, and any missing information.”
Recommended workflow for reliable execution
Start with discovery every time:
RUBE_SEARCH_TOOLS with a use case such as "Radar operations for checking recent events" or "Radar workflow for updating a record".
Then check the Radar connection through RUBE_MANAGE_CONNECTIONS. Once active, use the tool slug and input schema returned by Rube rather than relying on memory. Keep the same session ID where possible so the tool search, connection check, and execution plan stay linked.
This matters because Composio tool schemas can change. The skill’s highest-value behavior is preventing schema drift and tool-name guessing.
Files to read before adopting
The repository path is composio-skills/radar-automation, and the important file is SKILL.md. Read it before installing if you need to validate operational assumptions. It contains the prerequisites, Rube MCP setup, tool-discovery pattern, and the core “discover, check connection, execute” flow. There are no extra scripts or reference folders in this skill, so adoption mainly depends on whether your client supports MCP and whether your Radar connection can be authorized.
radar-automation skill FAQ
Is radar-automation useful if I do not use Rube MCP?
No. The skill is specifically designed for Composio’s Rube MCP. Without RUBE_SEARCH_TOOLS, it loses its main safety mechanism. If your environment uses a direct Radar API integration instead of Rube, you may be better served by a custom skill that documents your API endpoints, auth method, and allowed actions.
Can beginners use this skill?
Yes, if they can follow the connection flow. The skill itself is short and opinionated, which helps beginners avoid guessing tool schemas. The harder part is understanding MCP availability and confirming the Radar toolkit connection is active before requesting automation.
What tasks can radar-automation perform?
It can perform the Radar operations exposed by the Composio Radar toolkit at runtime. The exact actions should be discovered with RUBE_SEARCH_TOOLS, not assumed from the skill text. Treat the skill as a live-tool orchestration guide rather than a complete list of Radar capabilities.
When should I not use this skill?
Do not use it for offline planning, mock data work, or environments where the agent is not allowed to call external MCP tools. Also avoid it when you need deterministic, audited production automation with fixed schemas and change control; in that case, a coded integration may be safer than an interactive agent workflow.
How to Improve radar-automation skill
Improve radar-automation prompts with execution boundaries
The most important improvement is telling the agent what it may and may not do. For read-only work, say “inspect only” and request a summary before any write action. For change workflows, specify whether the agent should ask for confirmation after tool discovery and before execution. This reduces accidental writes and makes the tool plan reviewable.
Provide better discovery language
Tool discovery quality depends on the use case you send to RUBE_SEARCH_TOOLS. Instead of "Radar task", use language like "find the Radar tool for reviewing recent events for a known user" or "identify the Radar tool for updating a record after confirming required fields". Specific discovery prompts return more relevant tool slugs, schemas, and pitfalls.
Watch for common failure modes
The main failure modes are inactive Radar authorization, missing identifiers, stale assumptions about tool parameters, and skipping RUBE_SEARCH_TOOLS. If the first attempt fails, ask the agent to report which step failed: MCP availability, Radar connection, tool discovery, schema validation, or execution. That makes the retry actionable instead of repeating the same vague request.
Iterate after the first output
After the first radar-automation run, improve the workflow by saving the successful use case wording, required fields, and confirmation rules. For recurring operations, turn your best prompt into a checklist: discover tool, verify connection, map fields, confirm write permissions, execute, summarize result. This preserves the skill’s schema-discovery advantage while making future runs faster and more consistent.