Pagerduty Automation

Automate PagerDuty tasks via Rube MCP (Composio): manage incidents, services, schedules, escalation policies, and on-call rotations. Always search too

Category: productivity Source: davepoon/buildwithclaude

What Is Pagerduty Automation?

Pagerduty Automation is a technical skill built for the Claude Code and Rube MCP ecosystem, enabling seamless automation of core PagerDuty operations. Leveraging the Composio PagerDuty toolkit, this skill allows developers and SREs to programmatically manage incidents, services, schedules, escalation policies, and on-call rotations. By interfacing through the Rube MCP orchestration layer, you gain low-friction, API-driven access to PagerDuty workflows without manual API key management or custom integration code. The skill is designed to always search for and use the latest tool schemas, ensuring compatibility with evolving PagerDuty APIs and Composio toolkit updates.

Why Use Pagerduty Automation?

Pagerduty Automation addresses several pain points in incident response and operations engineering:

Reduced Toil: Manual incident triage, on-call scheduling, or escalation adjustments consume valuable engineering time. Automation eliminates repetitive steps and errors.
Consistency: Automated workflows ensure organizational policies are followed precisely, reducing risk of missed alerts or untracked incidents.
Speed: Automated incident creation, acknowledgment, or resolution shortens mean time to resolution (MTTR) and improves SLA compliance.
Integration: By connecting through Rube MCP and Composio, Pagerduty Automation fits into broader DevOps toolchains without requiring direct API key handling, custom scripts, or fragile webhooks.
Search-First Schema Discovery: Always using the latest tool schemas prevents compatibility issues with upstream API changes, reducing maintenance overhead.

For incident response teams, platform engineers, or DevOps practitioners, Pagerduty Automation brings robust, reliable, and extensible automation to your PagerDuty environment.

How to Get Started

To begin using Pagerduty Automation, follow these steps:

Connect to Rube MCP
Add the Rube MCP endpoint to your client configuration:
```
https://rube.app/mcp
```
No API keys are required. Ensure your client recognizes Rube MCP and can call its search and management endpoints.
Verify MCP Availability
Test connectivity by calling:
```
RUBE_SEARCH_TOOLS()
```
This should return a list of available tools, confirming Rube MCP is active.
Establish PagerDuty Toolkit Connection
Initiate the PagerDuty connection:
```
RUBE_MANAGE_CONNECTIONS(toolkit="pagerduty")
```
If the connection is not yet active, the response will include an authentication link. Complete the OAuth process in your browser.
Confirm Connection Status
Re-run the connection check:
```
RUBE_MANAGE_CONNECTIONS(toolkit="pagerduty")
```
The status must be ACTIVE before running any workflows.
Always Search Tool Schemas First
Before invoking any PagerDuty action, call:
```
RUBE_SEARCH_TOOLS()
```
This ensures you are using the latest available schema for each operation.

Key Features

Pagerduty Automation supports a comprehensive set of workflows. Below are some of the core capabilities with practical code examples.

1. Incident Management

List Incidents

# Fetch all open incidents assigned to a user
PAGERDUTY_FETCH_INCIDENT_LIST(status="triggered", assignee_email="devops@example.com")

Retrieve Incident Details

# Get details for a specific incident
PAGERDUTY_RETRIEVE_INCIDENT_BY_INCIDENT_ID(incident_id="PABC123")

Acknowledge or Resolve Incidents

# Acknowledge an incident
PAGERDUTY_ACKNOWLEDGE_INCIDENT(incident_id="PABC123")

# Resolve an incident
PAGERDUTY_RESOLVE_INCIDENT(incident_id="PABC123")

Create New Incidents

PAGERDUTY_CREATE_INCIDENT(
    title="Critical outage: API down",
    service_id="SVC456",
    urgency="high",
    body="Production API is unresponsive"
)

2. Service and Schedule Management

List Services
```
PAGERDUTY_FETCH_SERVICE_LIST()
```

Manage Schedules

PAGERDUTY_FETCH_SCHEDULE_LIST()
PAGERDUTY_UPDATE_SCHEDULE(schedule_id="SCH789", new_layer_params={...})

3. Escalation Policies and On-Call Rotations

List and Update Escalation Policies

PAGERDUTY_FETCH_ESCALATION_POLICY_LIST()

View On-Call Schedules
```
PAGERDUTY_FETCH_ONCALL_LIST()
```

All tool invocations should be preceded by schema discovery using RUBE_SEARCH_TOOLS().

Best Practices

Always Perform Schema Discovery: Start every workflow by calling RUBE_SEARCH_TOOLS() to obtain the current operation signatures and parameter requirements.
Handle Connection Status Programmatically: Before attempting any automated action, verify the PagerDuty connection is ACTIVE to prevent authentication errors.
Use Specific Filters: When listing incidents or resources, apply filters (e.g., status, assignee, service) to minimize data volume and API load.
Automate Common Playbooks: Encode frequent incident response steps (such as bulk acknowledgment or escalation) into reusable scripts.
Audit and Log Actions: Maintain an audit trail of automated actions for compliance and troubleshooting.

Important Notes

No Direct API Keys Needed: Authentication is managed through Rube MCP and OAuth, minimizing credential exposure.
Always Use Latest Schemas: The Composio toolkit and PagerDuty API evolve; always discover and use the latest available schemas to avoid breaking changes.
Error Handling: Implement robust error handling in your automation scripts, especially for connection status, API rate limits, and unexpected schema changes.
Security: Only authorized users should connect and automate PagerDuty actions, as these can impact incident response and on-call operations.
Documentation: Refer to the Composio PagerDuty Toolkit documentation for up-to-date operation references and usage examples.

Pagerduty Automation, when integrated with Rube MCP and Composio, offers a highly extensible, secure, and maintainable way to automate PagerDuty workflows within modern DevOps environments.