# How to connect PagerDuty to Hermes Agent (no API keys)

> Connect PagerDuty to Hermes with ClawLink in one click — 363 tools your AI agent can call from chat via hosted OAuth. No API keys, no manual setup.

Web version: https://claw-link.dev/hermes/pagerduty

Most guides for giving Hermes Agent PagerDuty access start with registering your own OAuth app or pasting API keys into env files, then leave the token refresh and tool wiring to you. ClawLink gives Hermes a more practical PagerDuty setup: pair once in the browser and your always-on Hermes agent can act on PagerDuty for you, reading and doing real work on your behalf with no auth, token refresh, or tool wiring to build yourself.

**Start here — paste this into Hermes to set up ClawLink:**

> Set up ClawLink for Hermes and tell me when it's ready.
> 1. Install the plugin: `hermes plugins install ClawLink-HQ/hermes-plugin --enable`
> 2. Start pairing with `hermes clawlink begin`. It prints an approval link, so show me the link and stop, don't wait.
> 3. I'll approve it in my browser, then reply "approved".
> 4. When I say approved, finish setup: `hermes clawlink finish`
> 5. Then run `hermes clawlink test` and tell me whether ClawLink is ready.

## Setup

It takes three steps to connect Hermes to PagerDuty.

1. **Install ClawLink** — add the plugin to Hermes Agent once.
2. **Connect PagerDuty** — one-click OAuth in the ClawLink dashboard.
3. **Use it from chat** — ask Hermes Agent in plain English.

**Alternative for any agent (no plugin needed):** if the Hermes Agent plugin route isn't available or doesn't work, any AI agent with shell access can use the ClawLink CLI instead:

```bash
npx -y @useclawlink/cli login          # sign in via browser — no API key to paste
npx -y @useclawlink/cli connect pagerduty  # connect PagerDuty (browser OAuth)
npx -y @useclawlink/cli actions pagerduty  # list available actions
npx -y @useclawlink/cli run pagerduty <action> --input '<json>'  # execute (add --confirm for writes)
```

### Install by command

The prompt above walks Hermes through this. By hand, it is four commands and a browser approval:

```bash
hermes plugins install ClawLink-HQ/hermes-plugin --enable
hermes clawlink begin    # prints an approval link — open it and approve
hermes clawlink finish   # after approving in the browser
hermes clawlink test
```

Then connect PagerDuty in the [ClawLink dashboard](https://claw-link.dev/dashboard) — a one-click OAuth approval, no API keys.

Verify the connection by asking Hermes:

> Use pagerduty_fetch_incident_list and show me open incidents grouped by urgency and service. Flag anything that has been open longer than its service's typical resolution time.

### Using a different agent?

The Hermes plugin is one client of ClawLink's MCP server. Claude Code, Cursor, Codex, or any agent that can run a shell command pairs with the same ClawLink account through the CLI:

```bash
npx -y @useclawlink/cli login
```

`login` opens the same browser approval and stores a credential locally. Once PagerDuty is connected in the dashboard, that agent calls the same 363 PagerDuty tools over MCP. Full setup for MCP clients and shell agents: [connect apps to any AI agent](https://claw-link.dev/learn/connect-apps-to-any-ai-agent).

## PagerDuty MCP for Hermes

Looking for a PagerDuty MCP server for Hermes Agent? ClawLink connects PagerDuty to Hermes Agent and exposes 363 PagerDuty tools your agent can call over [MCP](https://claw-link.dev/learn/what-is-an-mcp-server), with [hosted auth](https://claw-link.dev/learn/oauth-for-ai-agents) and nothing to run or maintain yourself. Using OpenClaw instead? The [OpenClaw PagerDuty integration](https://claw-link.dev/openclaw/pagerduty) works the same way.

PagerDuty authenticates through hosted OAuth here, which makes this page's claim unusually checkable: you never generate a PagerDuty API token, and there is no `Token token=` header to format. The setup search results teach for Hermes is the opposite: a Composio Connect MCP URL plus an API key from a dev dashboard, pasted into a Hermes config. This flow is the plugin pair, a browser approval of the PagerDuty account, and then the 363 tools below are callable from chat. The connection is bound to the PagerDuty user who approves it, so everything the tools can do is bounded by what that user can do, which matters more on PagerDuty than most providers because roles here decide 403s.

## What the Hermes Agent PagerDuty integration can do

363 PagerDuty tools are ready for Hermes Agent once the account is connected. The 30 below are the ones people reach for most; your agent can call all 363.

### 30 of 363 PagerDuty tools for Hermes

| Tool | What it does |
|---|---|
| **Add service to incident workflow trigger** `pagerduty_add_service_to_incident_workflow_trigger` | Adds a service to an existing incident workflow trigger in PagerDuty, enabling the trigger to fire for incidents on that service. |
| **Aggregate escalation policy incident metrics** `pagerduty_aggregate_escalation_policy_incident_metrics` | This endpoint analyzes and aggregates incident metrics across all escalation policies in PagerDuty. |
| **Aggregate incident metrics with filters** `pagerduty_aggregate_incident_metrics_with_filters` | Retrieves and aggregates metrics for incidents across all services in PagerDuty. |
| **Associate service dependencies** `pagerduty_associate_service_dependencies` | Associates multiple service dependencies in PagerDuty, allowing you to define relationships between supporting and dependent services. |
| **Associate team with automation action** `pagerduty_associate_team_with_automation_action` | This endpoint associates a specific team with an automation action in PagerDuty. |
| **Audit escalation policy records** `pagerduty_audit_escalation_policy_records` | Retrieves the audit records for a specific escalation policy in PagerDuty. |
| **Convert service rule by ID** `pagerduty_convert_service_rule_by_id` | Converts a service's Event Rules to Event Orchestration rules. |
| **Count paused incident reports** `pagerduty_count_paused_incident_reports` | Retrieves the count of paused incident reports in the PagerDuty system. |
| **Create a custom field for an incident type** `pagerduty_create_a_custom_field_for_an_incident_type` | Create a Custom Field for an Incident Type. |
| **Create a field option for a custom field** `pagerduty_create_a_field_option_for_a_custom_field` | Creates a new field option for a custom field on an incident type. Field options represent the allowed values for multi-value or dropdown custom fields. Before using this action: 1. |
| **Create a ruleset** `pagerduty_create_a_ruleset` | Creates a new Ruleset in PagerDuty for managing incident routing and notification rules. |
| **Create a trigger** `pagerduty_create_a_trigger` | Creates a new incident workflow trigger in PagerDuty. Triggers define when and how incident workflows are activated - either automatically based on conditions or manually by responders. |
| **Fetch cache variable for event orchestration** `pagerduty_fetch_cache_variable_for_event_orchestration` | Retrieves detailed information about a specific cache variable in a PagerDuty event |
| **Fetch custom incident field by ID** `pagerduty_fetch_custom_incident_field_by_id` | Retrieves detailed information about a specific custom field associated with incidents in |
| **Fetch escalation polices list** `pagerduty_fetch_escalation_polices_list` | Retrieves a list of escalation policies configured in the PagerDuty account |
| **Fetch event orchestrations** `pagerduty_fetch_event_orchestrations` | Retrieves a list of event orchestrations configured in the PagerDuty account |
| **Fetch incident analytics by ID** `pagerduty_fetch_incident_analytics_by_id` | Retrieves raw analytics data for a specific incident in PagerDuty |
| **Fetch incident list** `pagerduty_fetch_incident_list` | Retrieves a list of incidents from PagerDuty based on specified criteria |
| **Fetch outlier incident by ID** `pagerduty_fetch_outlier_incident_by_id` | Retrieves detailed information about an outlier incident associated with a specific incident in |
| **Fetch post update status** `pagerduty_fetch_post_update_status` | Retrieves detailed information about a specific post update on a PagerDuty status page |
| **Fetch priorities list** `pagerduty_fetch_priorities_list` | Retrieves a list of existing priorities in the PagerDuty system, ordered from most severe to |
| **Fetch related change events for incident** `pagerduty_fetch_related_change_events_for_incident` | Retrieves change events correlated with a specific incident, along with the reasons for |
| **Fetch related incidents by ID** `pagerduty_fetch_related_incidents_by_id` | Retrieves a list of incidents that are potentially related to a specified incident in PagerDuty |
| **Fetch runner teams integration** `pagerduty_fetch_runner_teams_integration` | Retrieves a list of teams associated with a specific Automation Action Runner in PagerDuty |
| **Fetch status pages** `pagerduty_fetch_status_pages` | Retrieves a list of all status pages configured in the PagerDuty account |
| **Fetch user contact method** `pagerduty_fetch_user_contact_method` | Retrieves detailed information about a specific contact method for a particular user in |
| **Fetch vendor list** `pagerduty_fetch_vendor_list` | Retrieves a list of vendors or third-party integrations available in the PagerDuty platform |
| **Filter and aggregate incident metrics** `pagerduty_filter_and_aggregate_incident_metrics` | Analyzes and aggregates incident metrics across teams in PagerDuty, allowing for detailed |
| **Get a field option on a custom field** `pagerduty_get_a_field_option_on_a_custom_field` | Retrieves a specific field option from a custom field on an incident type |
| **Get a trigger** `pagerduty_get_a_trigger` | Retrieves details of a specific incident workflow trigger by ID |

## Example prompts

**Triage open incidents**

> Use pagerduty_fetch_incident_list and show me open incidents grouped by urgency and service. Flag anything that has been open longer than its service's typical resolution time.

**Map the on-call structure**

> Pull the escalation policies with pagerduty_fetch_escalation_polices_list and the priorities list. Tell me which teams own which policies and where there is no first-line responder.

**Analyze incident load**

> Use pagerduty_aggregate_incident_metrics_with_filters to aggregate incidents over the last 30 days across services. Tell me which three services generate the most incidents and how mean resolution time differs by priority.

**Check status pages**

> List the status pages with pagerduty_fetch_status_pages and tell me the current status of each. If any shows anything other than a green state, quote it exactly.

## How the PagerDuty tools behave

Details that decide whether a PagerDuty prompt is a fast answer or a rate-limited crawl.

- **Ids, not names.** Incidents, escalation policies, services, and teams are addressed by id; the list tools are where ids come from. An id from documentation fails like a typo.
- **Analytics come pre-aggregated.** `pagerduty_aggregate_incident_metrics_with_filters`, `pagerduty_filter_and_aggregate_incident_metrics`, and `pagerduty_aggregate_escalation_policy_incident_metrics` move the aggregation server-side, which is the difference between one call and walking every incident.
- **The user role is the ceiling.** The connected PagerDuty user's base role bounds everything: Responder, Manager, and Global Admin see and change different things, and limited users hit 403s on administrative endpoints.
- **Status pages and priorities are readable.** `pagerduty_fetch_status_pages`, `pagerduty_fetch_post_update_status`, and `pagerduty_fetch_priorities_list` answer the questions on-call people actually ask without touching incidents.
- **Writes change routing and policy.** Adding a service to a workflow trigger, creating rulesets, custom fields, and field options changes shared incident behavior, so a confirmation step in the prompt is worth it.
- **Incident workflows and orchestrations exist as their own surface.** `pagerduty_fetch_event_orchestrations` and the trigger tools are how the agent inspects and changes automated incident routing, not just reads incidents.

## ClawLink vs. building it yourself

The alternative to ClawLink is usually manual OAuth app setup plus your own token handling, permission troubleshooting, and tool plumbing for Hermes Agent. That is fine if you want to build and maintain the integration yourself. Most teams just want PagerDuty working from chat.

| | Manual | ClawLink |
|---|---|---|
| **Connection flow** | Register a PagerDuty app, configure redirect URLs, manage consent details, and reconnect users when auth settings drift. | Users connect PagerDuty through the hosted browser flow and ClawLink keeps the token lifecycle out of your app code. |
| **Ongoing maintenance** | You own refresh logic, permission debugging, environment config, and every provider-specific edge case for PagerDuty. | ClawLink handles the repetitive integration plumbing so your team can focus on the workflow instead of the infrastructure. |
| **Agent usability** | You still need to expose the right PagerDuty actions to the runtime in a format your agent can reliably use. | 363 tools for PagerDuty are already exposed through ClawLink, so the agent can read and act from chat immediately. |

## ClawLink vs. Composio

Composio also exposes PagerDuty to AI agents. It is developer infrastructure: Python and TypeScript SDKs, an MCP server, and a catalog past 1,000 apps, aimed at teams shipping agent products. ClawLink is built for Hermes Agent users instead. You install the plugin once, connect PagerDuty in the browser, and the 363 tools above work from chat. There is no SDK, no config file, and no API key handling. Choosing between them? Read the full [Composio alternatives](https://claw-link.dev/hub/composio-alternatives) comparison.

### Hermes paired but still can't use PagerDuty
Pairing is a two-step handshake: run `hermes clawlink begin`, approve the link in your browser, then run `hermes clawlink finish`. If you ran finish before approving, or the approval link expired, run `hermes clawlink begin` again to get a fresh link. Confirm the plugin was installed with `--enable`, then verify with `hermes clawlink test`.

### Connection succeeds but no tools appear
Reconnect PagerDuty from the dashboard, then start a fresh chat if the runtime still has the old tool catalog loaded.

### "Tool schema not loaded yet" error when calling PagerDuty tools
PagerDuty tool schemas load on demand the first time a tool runs and are cached after that, so this error usually clears on its own: wait a few seconds and retry the same request. If every PagerDuty call keeps failing with it in a fresh chat, reconnect from the dashboard, and contact support if it still persists — that pattern points to a configuration problem on our side, not something you can fix by reconnecting again.

### PagerDuty returns 403 or "permission denied" on one action while others work
Two usual causes. The connected account may not have access to the specific workspace, inbox, store, or project in the request — check that first. If access looks right, the agent may have sent a placeholder value (like "YOUR_ID" or an example id from documentation) instead of a real one: ask it to run a list or search tool first, then retry the action with a real id from those results. Most failures at this stage are one of these two, not ClawLink bugs.

### PagerDuty returns 403 or permission denied on some actions while others work
Start with the cause the engines teach first and our old card missed: the connected PagerDuty user's base role. A limited user returns 403 on most administrative endpoints, and a Responder role cannot modify schedules or teams even though it can see incidents. The connection is bound to the user who approved the OAuth grant, so the fix is not a new token, it is either a user with the right role approving the connection, or accepting that the connected user's role is the ceiling. After roles, the other causes line up in order: OAuth scopes and advanced permissions at the account level, resource-level restrictions, and then the hosted-agent causes, workspace access and placeholder ids, where an id like an example incident id from documentation fails as a permission error because the object belongs to another account.

Ask the agent to diagnose it:

```text
Call pagerduty_fetch_incident_list and pagerduty_fetch_escalation_polices_list and tell me which succeeds. Then quote the exact error body from the failed call. Do not retry it yet.
```

### PagerDuty tools are missing, or a tool name is not found
One explicit line first, because it answers a whole class of searches: the engine-taught causes for this error are all self-hosted MCP config problems, a missing Bearer prefix breaking the handshake, a server started without `--enable-write-tools`, a stale npx cache, an EU endpoint (`mcp.eu.pagerduty.com`) mismatch, and hosted connections do not see any of them. There is no server process here to misconfigure. What this setup does have is the lazy-schema timing case: schemas load on demand, so the opening PagerDuty call in a fresh session can arrive before the catalog and needs one retry. If no tools appear after that, the pairing is incomplete, confirm both `hermes clawlink begin` and `hermes clawlink finish` ran and PagerDuty shows as connected.

Ask the agent to diagnose it:

```text
List the PagerDuty tools you actually have. If there are none, say so plainly. If there are, tell me which one fetches an incident list and use that exact name.
```

### PagerDuty returns 401 or the connection acts like the credential is invalid
On this setup there is no Authorization header for you to format and no local config to inspect, which removes most of the standard advice for this error. What is left is the grant itself. If the connected PagerDuty user's access changed, if the account was re-created or the user removed, every tool fails from that moment even though the dashboard still shows a connection. The same happens if the connection predates a PagerDuty policy change that affected the account's API access. The fix is to disconnect and reconnect from the ClawLink dashboard, which re-runs the OAuth approval and issues a fresh grant, and to confirm the approving user still has an active account.

Ask the agent to diagnose it:

```text
Call pagerduty_fetch_vendor_list, the cheapest call in the set, and tell me exactly what it returns. Do not retry the failing tools until we have that result.
```

### PagerDuty starts returning 429 or the agent stalls partway through an incident sweep
PagerDuty rate-limits its API, and an agent walking a queue of incidents, then escalation policies, then analytics, one call at a time, is exactly the traffic shape that meets the limit. The response is not to retry immediately but to change the shape of the work: ask for the open incident list with its status filter, or one incident's details, rather than a whole-account sweep, and have the agent say what it intends to call before it starts. The 429 response carries the remaining-allowance headers, so the agent can report where it stands instead of guessing. If a genuine bulk analysis is needed, run it in stages across turns.

Ask the agent to diagnose it:

```text
Tell me how many PagerDuty calls you have made in the last minute and what you were enumerating. Quote any rate-limit headers from the last response. Do not call PagerDuty again until I reply.
```

### OAuth finished in the browser but the account is still missing
Try reconnecting PagerDuty and complete the consent flow in the same browser session. Partial OAuth approvals or switching accounts mid-flow can leave the connection incomplete.

### Is there a Hermes Agent PagerDuty integration?
Yes. ClawLink is the fastest way to connect Hermes to PagerDuty: link your PagerDuty account once in the browser and Hermes Agent can call the PagerDuty API through 363 ready-made tools — no custom code or token handling.

### How do I connect PagerDuty to Hermes with ClawLink?
Install the plugin with `hermes plugins install ClawLink-HQ/hermes-plugin --enable`, then pair once: run `hermes clawlink begin`, approve the link in your browser, and run `hermes clawlink finish`. Connect PagerDuty in the dashboard and Hermes can use it from the next message — no config files or API keys to manage.

### How long does it take to connect PagerDuty to Hermes Agent?
About two minutes. Sign in, click Connect next to PagerDuty in the dashboard, authenticate, and Hermes Agent can use it from the next chat message.

### Why use ClawLink instead of wiring PagerDuty up myself?
The alternative to ClawLink is usually manual OAuth app setup plus your own token handling, permission troubleshooting, and tool plumbing for Hermes Agent. That is fine if you want to build and maintain the integration yourself. Most teams just want PagerDuty working from chat.

### Do I need a PagerDuty API token?
No, and that is the one claim worth stating twice because it contradicts what Google currently shows first for the primary query: the AI Overview for "how to connect pagerduty to hermes" teaches grabbing a Connect MCP URL and an API key from the Composio Dev Dashboard and pasting them into Hermes. The key in that story is a consumer key for the integration layer, not a PagerDuty token, but the searcher cannot tell. Here the OAuth approval is the whole story: the credential that exists afterwards is the PagerDuty grant held server-side, it can be revoked from the ClawLink dashboard, and there is nothing for you to rotate.

### What can the agent do in PagerDuty?
Read and write the incident operations surface: incidents and their analytics, escalation policies, priorities, status pages, teams, contact methods, event orchestrations and rulesets, custom fields, and workflow triggers. Incident reads and analytics are the safe default and answer most questions on call: what is open, what is overdue, which services keep generating incidents, what escalated when. The writes to be deliberate about are the ones that change routing and policy: adding a service to a workflow trigger, creating rulesets, custom fields, and field options. The agent sees exactly what the connected user can see, so its ceiling is your role, not the API's.

### How is this different from PagerDuty's own MCP server or a self-built OAuth app?
Both of those are real paths and both are what the engines teach for the no-token shape: ChatGPT's p2 answer is "build a PagerDuty OAuth app (recommended)" or use PagerDuty's hosted MCP server with OAuth. That describes our exact value proposition as engineering work for you to do: register an app, manage the redirect, stand up the client. Here the OAuth plumbing is done, the plugin pairing is the entire client-side story, and PagerDuty sits alongside your other connected accounts with one place to revoke. Choose on how much you want to run, not on features, because the underlying API is the same.

### Do I need PagerDuty Advance or one of the SRE add-ons?
No. The "without api key" answers sometimes lead with PagerDuty's own AI agents inside Slack, which are paywalled add-ons that need an Admin role to set up. That is a different product from connecting the API to an agent. The tools on this page use the standard PagerDuty API and your normal account's access: incidents, escalation policies, analytics, status pages. If the question is "how do I let an agent operate PagerDuty without handing out API keys", the hosted connection is the answer, and no add-on purchase is involved.

### Hermes paired but still can't use PagerDuty
Pairing is a two-step handshake: run `hermes clawlink begin`, approve the link in your browser, then run `hermes clawlink finish`. If you ran finish before approving, or the approval link expired, run `hermes clawlink begin` again to get a fresh link. Confirm the plugin was installed with `--enable`, then verify with `hermes clawlink test`.

## Related

- [SafetyCulture](https://claw-link.dev/hermes/safetyculture) — SafetyCulture (formerly iAuditor) is a workplace operations platform that enables teams to conduct digital inspections, manage audits, track issues, schedule tasks, and maintain compliance through mobile and web applications.
- [Connect LaunchDarkly](https://claw-link.dev/hermes/launch-darkly) — A feature management platform that helps teams build better software faster using feature flags.
- [Crowdin](https://claw-link.dev/hermes/crowdin) — Manage translations, localization projects, and language resources