# How to connect Make to Hermes Agent (paste one key, 25 tools)

> Connect Make to Hermes Agent with ClawLink: paste one key and 25 Make tools work from chat — account, organisation, team and operations data. Scenario execution lives in Make's own MCP server; this page explains which you want.

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

Most guides for giving Hermes Agent Make 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 Make setup: pair once in the browser and your always-on Hermes agent can act on Make 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 Make.

1. **Install ClawLink** — add the plugin to Hermes Agent once.
2. **Connect Make** — 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 make  # connect Make (browser OAuth)
npx -y @useclawlink/cli actions make  # list available actions
npx -y @useclawlink/cli run make <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 Make in the [ClawLink dashboard](https://claw-link.dev/dashboard) — paste your Make API key once.

Verify the connection by asking Hermes:

> Call make_get_current_authorization and make_get_users_me, and tell me which Make user and account this connection is acting as.

### 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 Make is connected in the dashboard, that agent calls the same 25 Make 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).

## Make MCP for Hermes

Looking for a Make MCP server for Hermes Agent? ClawLink connects Make to Hermes Agent and exposes 25 Make 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 Make integration](https://claw-link.dev/openclaw/make) works the same way.

Be clear about what this connection is for, because Make is itself an automation platform and the obvious assumption is wrong. These 25 tools read your Make account: the organisations and teams you belong to, your operations usage, the current authorization, and the enumerations Make's API exposes. There is no tool here that runs a scenario, lists your scenarios, or triggers one. If what you want is an agent that executes your Make scenarios, Make's own MCP server is the thing that does that, and you should use it. If what you want is an agent that can answer questions about the account — which teams exist, what the operations usage looks like, which organisation a key belongs to — that is this, and it is one pasted key with no `config.yaml` to edit and nothing to run on your machine.

## What the Hermes Agent Make integration can do

25 Make tools are ready for Hermes Agent once the account is connected.

### All 25 Make tools for Hermes

| Tool | What it does |
|---|---|
| **Create organizations** `make_create_organizations` | Create a new organization |
| **Get cashier prices** `make_get_cashier_prices` | Get pricing details |
| **Get cashier products** `make_get_cashier_products` | List available subscription products |
| **Get current authorization** `make_get_current_authorization` | Get current authorization and scopes |
| **Get enums imt regions** `make_get_enums_imt_regions` | List Make regions |
| **Get enums llm models** `make_get_enums_llm_models` | List available LLM models |
| **Get enums module types** `make_get_enums_module_types` | List module types |
| **Get operations** `make_get_operations` | Get daily operations usage |
| **Get users me** `make_get_users_me` | Get current user profile |
| **List enums countries** `make_list_enums_countries` | List supported countries |
| **List organizations** `make_list_organizations` | List organizations you belong to |
| **List teams** `make_list_teams` | List teams in an organization |
| **Ping API** `make_ping_api` | Ping Make API to verify connectivity |
| **Get enums apps review statuses** `make_get_enums_apps_review_statuses` | Retrieve available app review statuses in Make |
| **Get enums imt zones** `make_get_enums_imt_zones` | Retrieve available IMT zones in Make |
| **Get enums organization features** `make_get_enums_organization_features` | Retrieve available organization features in Make |
| **Get enums user API token scopes** `make_get_enums_user_api_token_scopes` | Retrieve all available API token scopes in Make |
| **Get enums user email notifications** `make_get_enums_user_email_notifications` | Retrieve available email notification types for Make users |
| **Get enums user features** `make_get_enums_user_features` | Retrieve the list of all existing user features and their descriptions |
| **Get enums variable types** `make_get_enums_variable_types` | Retrieve available variable types in Make |
| **List enums languages** `make_list_enums_languages` | Retrieve a list of language codes and names |
| **List enums llm builtin tiers** `make_list_enums_llm_builtin_tiers` | Retrieve all predefined LLM tiers (small, medium, large) with their associated models |
| **List enums locales** `make_list_enums_locales` | Retrieve all supported locales in Make |
| **List enums timezones** `make_list_enums_timezones` | Retrieve all supported timezones in Make |
| **Create users password reset demand** `make_create_users_password_reset_demand` | Create a password reset demand for a user by their email address |

## Example prompts

**Confirm which account you are on**

> Call make_get_current_authorization and make_get_users_me, and tell me which Make user and account this connection is acting as.

**Check operations usage**

> Use make_get_operations to tell me how many Make operations have been consumed, and flag it if usage looks high for this point in the billing period.

**Map the organisation**

> List my Make organisations with make_list_organizations and the teams in each with make_list_teams. Give me a simple tree.

**Check the connection is alive**

> Run make_ping_api and tell me whether the Make API is reachable with the stored credential, before we rely on it for anything else.

## What the Make tools cover

A deliberately narrow surface. Knowing the edge saves a failed prompt on the first try.

- **No scenario execution, listing, or triggering.** The 25 tools are account, organisation, team, operations, and enum data. Make's own MCP server is what exposes scenarios as tools.
- **`make_get_current_authorization` is the first diagnostic.** It reports what the stored token actually is, which resolves most permission confusion before anything else is tried.
- **Visibility follows the token's owner.** Organisations and teams are enumerated as the user who created the token, so an empty list is often a correct answer rather than a failure.
- **`make_get_operations` is the usage check.** Operations are Make's billing unit, so this is the tool worth running before anyone enables something expensive.
- **The `make_get_enums_*` family is reference data.** Countries, locales, timezones, module types, LLM models and similar — useful for validating input to other systems, not for driving automations.
- **Two tools write.** `make_create_organizations` and `make_create_users_password_reset_demand` are real actions; nothing else in the set changes state.

## ClawLink vs. building it yourself

The alternative to ClawLink is usually manual API key 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 Make working from chat.

| | Manual | ClawLink |
|---|---|---|
| **Credential handling** | Collect, validate, store, and rotate the Make API key yourself, then make sure every tool call uses the right account. | Users complete the hosted ClawLink setup once and the connected Make account becomes available to the agent without you building credential management. |
| **Ongoing maintenance** | You own refresh logic, permission debugging, environment config, and every provider-specific edge case for Make. | 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 Make actions to the runtime in a format your agent can reliably use. | 25 tools for Make are already exposed through ClawLink, so the agent can read and act from chat immediately. |

## ClawLink vs. Composio

Composio also exposes Make 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 Make in the browser, and the 25 tools above work from chat. There is no SDK and no config file, and the Make key you paste at setup is stored server-side rather than kept in your environment. Choosing between them? Read the full [Composio alternatives](https://claw-link.dev/hub/composio-alternatives) comparison.

### Hermes paired but still can't use Make
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 Make 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 Make tools
Make 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 Make 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.

### Make 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.

### The agent says there is no tool for running a Make scenario
It is right, and it is not confused. This integration has no scenario execution, listing, or trigger tools — the surface is account, organisation, team, operations, and enum data. An agent that invents a plausible name like make_run_scenario is calling something that has never existed, and the error will list the closest real tools. If scenario execution is the goal, use Make's own MCP server, which exposes scenarios as tools; if you want the agent to react to a scenario finishing, that is a job for Make's webhooks pointed at whatever you want notified, not for this connection.

Ask the agent to diagnose it:

```text
List every Make tool you actually have access to, and tell me plainly whether any of them can execute a scenario. Do not guess at tool names.
```

### Make returns 401 or 403 although the connection shows as connected
This is a token integration, so "connected" means a token was accepted at setup, not that it is still valid. If the token was regenerated or deleted in Make afterwards, every call fails from that point and re-pasting the current one from the dashboard is the fix. If some calls succeed and others do not, the token is alive and you are looking at scope: Make tokens carry the permissions of the user who created them, so a token from a user without access to an organisation returns a permission error for it while working fine elsewhere. Run make_get_current_authorization first — it tells you what the token actually is before you change anything.

Ask the agent to diagnose it:

```text
Call make_get_current_authorization and make_get_users_me, then make_list_organizations. Tell me which Make user and organisations this token can see, and quote the exact error from the failed call.
```

### Organisation or team lists come back empty
Almost always the token's owner rather than a fault. Make scopes visibility to the user the token belongs to, so a token created by an account that belongs to one team enumerates that team and nothing else, and an empty list is an accurate answer for that user. Confirm which user you are acting as before assuming the call failed. make_ping_api is the cheapest way to separate "the API is unreachable" from "the API answered and there is genuinely nothing to show".

Ask the agent to diagnose it:

```text
Run make_ping_api, then make_get_users_me, then make_list_organizations and make_list_teams. Tell me which user this is and exactly what each call returned.
```

### API key setup works but results look incomplete
Double-check that the API key for Make has the right scopes or account access. A valid key can still be too limited for some reads or writes.

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

### How do I connect Make 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 Make in the dashboard and Hermes can use it from the next message — no config files, and the Make key you paste is stored server-side instead of in your environment.

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

### Why use ClawLink instead of wiring Make up myself?
The alternative to ClawLink is usually manual API key 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 Make working from chat.

### Can the agent run my Make scenarios?
No. This is the thing to check before you connect, because it is the natural expectation and the toolset does not support it. There is no run-scenario tool, no scenario listing, and no trigger — the 25 tools cover account, organisation, team, operations, and enum data. Make publishes its own MCP server that exposes scenarios as callable tools, and that is the right route for scenario execution. The two are not in competition: one answers questions about the account, the other runs the automations.

### Then what is this connection actually useful for?
Account-level questions an agent would otherwise make you go and look up. It can tell you which organisations and teams your key can see, how many operations you have consumed, what the current authorization is, and confirm the API is reachable. In practice that is most valuable as a check rather than as a workflow — confirming which Make account an automation is billing against, or reading operations usage before someone turns on something expensive. It is a narrow toolset and the page would rather say so than have you discover it on the first prompt.

### How is this different from connecting Make through Composio?
Mostly in what you have to run and edit. The Composio route that search results teach involves an MCP endpoint, an API key, and editing Hermes's `config.yaml` to point at it — a setup you then own and maintain. Here the plugin install and a one-time pairing handshake are the whole client-side story, the key lives server-side, and Make sits alongside your other connected accounts in one dashboard with one place to revoke. The underlying Make API is the same, so the capability limits above apply either way.

### Which key does Make need?
A Make API token, generated in your Make profile, pasted once into the hosted setup page. It carries the permissions of the user who created it, so the agent sees the organisations and teams that user can see — a token from an account with access to one team will not enumerate another. Because it is stored server-side rather than in an environment file, rotating it means updating it in one place, and removing the connection from the dashboard cuts access immediately.

### Hermes paired but still can't use Make
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

- [GitHub](https://claw-link.dev/hermes/github) — Manage repositories, issues, pull requests, and workflows
- [Connect PagerDuty](https://claw-link.dev/hermes/pagerduty) — Manage incidents, on-call schedules, and services
- [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.