# Playbook Recommendations

> Recommend relevant playbooks based on case or incident context by matching issue patterns to existing playbooks, scoring relevance, and suggesting customizations for better fit

- Skill: `happy-technologies-llc/playbook-recommendations` (Agent Skill)
- Install (CLI): `npx skillmds@latest add happy-technologies-llc/playbook-recommendations`
- Raw SKILL.md: https://api.skillmd.com/api/skills/happy-technologies-llc/playbook-recommendations/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: Happy-Technologies-LLC (https://skillmd.com/u/happy-technologies-llc)
- Updated: 2026-09-10
- Page: https://skillmd.com/skills/happy-technologies-llc/playbook-recommendations

---


# Playbook Recommendations

## Overview

This skill recommends relevant Process Automation Designer playbooks based on the context of an active case, incident, or HR case:

- Matching issue patterns (category, priority, symptoms) to existing playbook triggers and conditions
- Scoring playbook relevance based on historical success rates and contextual alignment
- Recommending specific playbooks with explanation of why they match
- Suggesting playbook customizations when no exact match exists
- Identifying gaps where new playbooks should be created
- Analyzing playbook execution history for effectiveness validation

**When to use:** When agents need guidance on which playbook to apply to an active record, when automating playbook selection in virtual agent flows, or when assessing playbook coverage across service categories.

## Prerequisites

- **Roles:** `process_automation_user`, `itil`, `sn_customerservice_agent`, or `admin`
- **Plugins:** `com.glide.process_automation` (Process Automation Designer)
- **Access:** Read access to `sys_pd_playbook`, `sys_pd_activity`, `sys_pd_context`, and source record tables
- **Knowledge:** Process Automation Designer concepts, playbook lifecycle, activity types
- **Related Skills:** `genai/playbook-generation` for creating new playbooks, `genai/flow-generation` for underlying flows

## Procedure

### Step 1: Retrieve the Source Record Context

Fetch the case or incident that needs a playbook recommendation.

**MCP Approach:**
```
Tool: SN-Get-Record
Parameters:
  table_name: incident
  sys_id: <incident_sys_id>
  fields: sys_id,number,short_description,description,category,subcategory,priority,impact,urgency,assignment_group,state,cmdb_ci,contact_type,caller_id
```

**REST Approach:**
```
GET /api/now/table/incident/<incident_sys_id>
  ?sysparm_fields=sys_id,number,short_description,description,category,subcategory,priority,impact,urgency,assignment_group,state,cmdb_ci,contact_type
  &sysparm_display_value=true
```

For CSM cases:
```
Tool: SN-Get-Record
Parameters:
  table_name: sn_customerservice_case
  sys_id: <case_sys_id>
  fields: sys_id,number,short_description,description,product,category,priority,account,contact,state,assignment_group
```

### Step 2: Query Available Playbooks

Retrieve all active playbooks that could apply to this record type.

**MCP Approach:**
```
Tool: SN-Query-Table
Parameters:
  table_name: sys_pd_playbook
  query: active=true^trigger_table=incident^ORDERBYorder
  fields: sys_id,name,description,trigger_table,trigger_condition,category,sys_updated_on,active,application
  limit: 50
```

**REST Approach:**
```
GET /api/now/table/sys_pd_playbook
  ?sysparm_query=active=true^trigger_table=incident^ORDERBYorder
  &sysparm_fields=sys_id,name,description,trigger_table,trigger_condition,category,sys_updated_on
  &sysparm_display_value=true
  &sysparm_limit=50
```

### Step 3: Retrieve Playbook Activities and Stages

For each candidate playbook, understand what it does by fetching its stages and activities.

**MCP Approach:**
```
Tool: SN-Query-Table
Parameters:
  table_name: sys_pd_stage
  query: playbook=<playbook_sys_id>^ORDERBYorder
  fields: sys_id,name,description,order,playbook,condition
  limit: 20
```

```
Tool: SN-Query-Table
Parameters:
  table_name: sys_pd_activity
  query: playbook=<playbook_sys_id>^ORDERBYorder
  fields: sys_id,name,description,activity_type,stage,order,condition,mandatory,inputs
  limit: 50
```

### Step 4: Match Playbooks to Record Context

Score each playbook against the source record using these criteria:

**Matching Criteria:**

| Criterion | Weight | How to Match |
|-----------|--------|-------------|
| Category match | 30% | Playbook trigger_condition includes record's category |
| Priority alignment | 15% | Playbook designed for this priority level |
| CI/Service match | 20% | Playbook targets the same CI type or service |
| Description similarity | 15% | NL similarity between record description and playbook description |
| Historical success | 20% | Playbook resolution rate for similar records |

**MCP Approach for historical matching:**
```
Tool: SN-Query-Table
Parameters:
  table_name: sys_pd_context
  query: playbook=<playbook_sys_id>^state=complete^ORDERBYDESCsys_created_on
  fields: sys_id,playbook,document_id,state,started,completed,duration
  limit: 50
```

### Step 5: Calculate Relevance Scores

Build a ranked list of playbook recommendations:

```
=== PLAYBOOK RECOMMENDATIONS ===
Record: INC0045678 - Email server not responding
Category: Email | Priority: P2 | CI: mail-server-prod-01

Rank | Playbook                        | Score | Match Reason
-----|---------------------------------|-------|------------------------------------------
#1   | Email Service Outage Response   | 92%   | Category: exact, CI type: mail server,
     |                                 |       | Success rate: 89% (45 past executions)
#2   | Server Connectivity Diagnostic  | 78%   | CI type: server, Description: "not
     |                                 |       | responding" pattern, Success: 76%
#3   | Network Service Restoration     | 65%   | Category: partial (network/email),
     |                                 |       | Priority: P2 match, Success: 82%
#4   | General Incident Triage         | 45%   | Generic fallback, always applicable,
     |                                 |       | Success: 71%

RECOMMENDED: #1 - Email Service Outage Response
Reason: Exact category match, designed for this CI type, 89% historical
success rate across 45 similar incidents.
```

### Step 6: Analyze Playbook Execution History

Check how the recommended playbook has performed historically.

**MCP Approach:**
```
Tool: SN-Query-Table
Parameters:
  table_name: sys_pd_context
  query: playbook=<recommended_playbook_sys_id>^state=complete^completed>javascript:gs.daysAgo(90)
  fields: sys_id,document_id,state,started,completed,duration
  limit: 100
```

Calculate metrics:
```
=== PLAYBOOK PERFORMANCE: Email Service Outage Response ===
Period: Last 90 days

Executions: 45
Completion Rate: 89% (40 completed, 5 abandoned)
Average Duration: 32 minutes
Median Duration: 25 minutes
Fastest Resolution: 8 minutes
Slowest Resolution: 2 hours 15 minutes

Resolution Outcome (from linked incidents):
- Resolved: 38 (84%)
- Escalated: 5 (11%)
- Workaround Applied: 2 (5%)
```

### Step 7: Suggest Playbook Customizations

When no playbook is an exact match, recommend modifications to the closest match:

```
=== CUSTOMIZATION SUGGESTIONS ===
Closest Match: Server Connectivity Diagnostic (78% relevance)

Suggested Modifications for Email-Specific Use:
1. ADD STAGE: "Check Email Service Status"
   - Activity: Query monitoring system for mail server health
   - Activity: Check mail queue depth via REST API

2. MODIFY STAGE: "Connectivity Tests"
   - Add email-specific port checks (25, 587, 993, 143)
   - Add SMTP handshake test activity

3. ADD ACTIVITY: "Notify Email Users"
   - Send communication to affected distribution list
   - Post status update to service status page

4. SKIP STAGE: "Database Connectivity" (not applicable to email)

Estimated Effort to Customize: 2-4 hours
Alternative: Create new playbook using genai/playbook-generation skill
```

### Step 8: Identify Playbook Coverage Gaps

Find categories or incident types with no matching playbooks.

**MCP Approach:**
```
Tool: SN-Query-Table
Parameters:
  table_name: incident
  query: active=true^sys_pd_contextISEMPTY^ORDERBYDESCsys_created_on
  fields: category,subcategory,priority,short_description
  limit: 100
```

Group by category to find unserved areas:
```
=== PLAYBOOK COVERAGE GAPS ===

| Category/Subcategory        | Open Incidents | Playbook Available |
|-----------------------------|---------------|-------------------|
| Hardware > Monitor Issues   | 23            | No                |
| Software > License Errors   | 18            | No                |
| Network > WiFi Connectivity | 15            | No                |
| Email > Calendar Sync       | 12            | No                |
| Database > Performance      | 8             | Yes (partial)     |

Priority Recommendation:
Create playbooks for "Hardware > Monitor Issues" and "Software > License Errors"
first (highest volume with no coverage).
```

### Step 9: Attach Playbook to Record (Optional)

If the recommendation is accepted, associate the playbook with the record.

**MCP Approach:**
```
Tool: SN-Update-Record
Parameters:
  table_name: incident
  sys_id: <incident_sys_id>
  data:
    u_recommended_playbook: "<playbook_sys_id>"
    u_playbook_relevance_score: "92"
```

### Step 10: Track Recommendation Effectiveness

Monitor whether recommended playbooks lead to successful outcomes.

**MCP Approach:**
```
Tool: SN-Query-Table
Parameters:
  table_name: sys_pd_context
  query: document_id=<incident_sys_id>^state=complete
  fields: sys_id,playbook,state,started,completed,duration
  limit: 5
```

## Tool Usage

| Tool | Purpose | When to Use |
|------|---------|-------------|
| SN-Query-Table | Fetch playbooks, execution history, incidents | Primary data retrieval and analysis |
| SN-Get-Record | Retrieve specific incident or case details | Getting source record context |
| SN-Natural-Language-Search | Find playbooks by description similarity | When category matching is insufficient |
| SN-Update-Record | Link recommended playbook to record | Recording the recommendation |

## Best Practices

1. **Weight historical success heavily** -- a playbook with 90% completion rate is better than a perfect category match with poor execution
2. **Consider playbook complexity** -- recommend simpler playbooks for P1 incidents where speed matters
3. **Check playbook currency** -- playbooks not updated in 6+ months may reference outdated procedures
4. **Factor in agent skill level** -- some playbooks require advanced technical skills
5. **Provide fallback recommendations** -- always include a generic triage playbook as a safety net
6. **Track recommendation acceptance** -- measure how often agents follow recommendations
7. **Update scoring weights** -- tune match criteria based on actual outcome data
8. **Consider time-of-day** -- some playbooks require resources only available during business hours
9. **Avoid playbook overload** -- recommend 3-5 options maximum, ranked by relevance
10. **Include explanation** -- agents need to understand why a playbook is recommended

## Troubleshooting

| Issue | Cause | Resolution |
|-------|-------|------------|
| No playbooks found | Wrong trigger_table or all inactive | Check `sys_pd_playbook.trigger_table` matches record type |
| All scores are low | Playbooks not aligned with current categories | Review and update playbook trigger conditions |
| Execution history empty | Playbooks recently created or never used | Fall back to category/description matching only |
| Recommendation mismatch | Scoring weights not calibrated | Analyze past recommendations vs outcomes, adjust weights |
| Context records missing | Process Automation tracking not enabled | Verify `sys_pd_context` records are being created |
| Playbook activities not returned | Activities use different table name | Check for `sys_pd_lane_activity` or version-specific table |

## Examples

### Example 1: Incident Playbook Recommendation

**Input:** "Recommend a playbook for INC0045678 - Email server not responding"

**Steps:** Retrieve incident details, query all active playbooks for incident table, score each against category/priority/CI/description, fetch execution history for top matches, return ranked list with explanations.

### Example 2: CSM Case Playbook Matching

**Input:** "What playbook should I use for this customer complaint about billing errors?"

**Steps:** Retrieve case details from `sn_customerservice_case`, query playbooks with `trigger_table=sn_customerservice_case`, match on product/category/description, recommend with customer satisfaction metrics from past executions.

### Example 3: Playbook Coverage Assessment

**Input:** "Show me which incident categories have no playbook coverage"

**Steps:** Query all active playbook trigger conditions, query all incident categories with volume counts, cross-reference to identify categories with incidents but no matching playbooks, prioritize gaps by incident volume.

## Related Skills

- `genai/playbook-generation` - Create new playbooks for identified gaps
- `genai/flow-generation` - Build underlying flows for playbook activities
- `itsm/incident-triage` - Incident categorization and routing
- `itsm/incident-lifecycle` - Incident management process
- `csm/case-summarization` - Customer case context for matching