home / skills / composiohq / awesome-claude-skills / anthropic-administrator-automation

anthropic-administrator-automation skill

/anthropic-administrator-automation

This skill automates Anthropic Admin operations via Rube MCP, always discovering current tool schemas before execution to ensure accurate, up-to-date workflows.

npx playbooks add skill composiohq/awesome-claude-skills --skill anthropic-administrator-automation

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

Files (1)

SKILL.md

3.0 KB

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

Overview

This skill automates Anthropic Admin tasks by driving Composio's Anthropic Administrator toolkit through Rube MCP. It provides a repeatable workflow: discover tools, verify connection, and execute schema-compliant operations reliably. The skill emphasizes always searching for current tool schemas before acting.

How this skill works

The skill uses RUBE_SEARCH_TOOLS to discover available Anthropic Admin tool slugs, input schemas, and execution plans. It verifies an active Anthropic Admin connection via RUBE_MANAGE_CONNECTIONS, then runs operations through RUBE_MULTI_EXECUTE_TOOL (or RUBE_REMOTE_WORKBENCH for bulk work), always including a memory block and session id. It checks for pagination and schema references using RUBE_GET_TOOL_SCHEMAS when needed.

When to use it

Automating user, policy, or resource management tasks in Anthropic Admin.
Running repeatable admin workflows that must adapt to changing tool schemas.
Batch or bulk operations that require stable session handling and memory context.
Integrating Anthropic Admin operations into CI/CD, monitoring, or governance pipelines.
When you need to programmatically confirm and refresh connections before execution.

Best practices

Always call RUBE_SEARCH_TOOLS first; never hardcode tool slugs or argument shapes.
Verify toolkit connection status with RUBE_MANAGE_CONNECTIONS and follow auth links until ACTIVE.
Include a memory object (even {}) in RUBE_MULTI_EXECUTE_TOOL calls and reuse session IDs per workflow.
Respect exact field names and types from the returned schema; use RUBE_GET_TOOL_SCHEMAS for full details.
Handle pagination tokens in responses and loop until all pages are fetched.
Generate new sessions for distinct workflows and reuse sessions within the same workflow.

Example use cases

Provision new Anthropic users and assign roles by discovering the relevant create-user tool and executing it with schema-compliant arguments.
Audit or list resources by searching for listing tools, handling pagination, and aggregating results.
Bulk update settings using RUBE_REMOTE_WORKBENCH and run_composio_tool() for high-volume changes.
Automated connection health checks that call RUBE_MANAGE_CONNECTIONS and trigger re-auth when not ACTIVE.
Scheduled governance tasks that fetch current schemas, run validation tools, and store results in workflow memory.

FAQ

What must I do before executing any tool?

Always run RUBE_SEARCH_TOOLS to fetch the current tool list and schemas, then confirm the toolkit connection is ACTIVE via RUBE_MANAGE_CONNECTIONS.

Can I hardcode tool argument shapes?

No. Tool schemas change; always use the field names and types returned by RUBE_SEARCH_TOOLS or RUBE_GET_TOOL_SCHEMAS.