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

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

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

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

1. **Install ClawLink** — add the plugin to Hermes Agent once.
2. **Connect Monday** — 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 monday  # connect Monday (browser OAuth)
npx -y @useclawlink/cli actions monday  # list available actions
npx -y @useclawlink/cli run monday <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 Monday in the [ClawLink dashboard](https://claw-link.dev/dashboard) — a one-click OAuth approval, no API keys.

Verify the connection by asking Hermes:

> List my boards with monday_boards, pick '\<board name>', then create an item with monday_create_item on that board, name '\<item name>', setting the \<column name> column value to '\<value>'. Confirm the item id.

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

## Monday MCP for Hermes

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

monday.com markets its own no-key story now: Agent Builder and Agent Factory build agents that live inside monday, and monday's hosted MCP at mcp.monday.com serves those and other clients. This page is not about those. It is about an external agent, Hermes Agent from Nous Research, acting on monday.com from chat without generating a token in the developer console. ClawLink's hosted OAuth flow handles the connection, and the account's existing permissions bound what the agent can do. If you want monday-native agents, monday's own products are the right tool; if you want your Hermes Agent to drive the same boards, this integration is the hosted route.

## What the Hermes Agent Monday integration can do

121 Monday 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 121.

### 30 of 121 Monday tools for Hermes

| Tool | What it does |
|---|---|
| **Add users to board** `monday_add_users_to_board` | Add users to a Monday board with a specified role |
| **Add users to team** `monday_add_users_to_team` | Add users to a Monday team |
| **Archive board** `monday_archive_board` | Archive a Monday board |
| **Archive item** `monday_archive_item` | Archive a Monday item |
| **Create board** `monday_create_board` | Create a new Monday board |
| **Create item** `monday_create_item` | Create a new item on a Monday board |
| **Create update** `monday_create_update` | Create an update on a Monday item |
| **Account trigger statistics** `monday_account_trigger_statistics` | Retrieve statistics about account-level triggers and automations |
| **Aggregate data** `monday_aggregate_data` | Aggregate data across Monday.com boards using groupings and aggregation functions like COUNT |
| **App subscription** `monday_app_subscription` | Retrieve current app subscription data for the account |
| **Audit logs** `monday_audit_logs` | Retrieve detailed security-related activity records for a Monday.com account |
| **Blocks** `monday_blocks` | Retrieve document block data from workdocs via the API |
| **Boards** `monday_boards` | Retrieve board data via the Monday.com API |
| **Columns** `monday_columns` | Retrieve column metadata from boards via the GraphQL API |
| **Connection board IDS** `monday_connection_board_ids` | Retrieve board IDs associated with connection columns |
| **Connections** `monday_connections` | Retrieve connection data for integrations with external services |
| **Custom activity** `monday_custom_activity` | Retrieve custom activity data from the Emails & Activities app |
| **Docs** `monday_docs` | Retrieve Monday.com document data via the API |
| **Get account info** `monday_get_account_info` | Retrieve account metadata and settings for the authenticated Monday.com account |
| **Get activity logs** `monday_get_activity_logs` | Retrieve activity logs from a specific Monday.com board |
| **Get API version** `monday_get_api_version` | Retrieve the Monday.com API version in use |
| **Get assets** `monday_get_assets` | Retrieve file/asset metadata from monday.com by asset IDs |
| **Get board views** `monday_get_board_views` | Retrieve board view data via GraphQL API |
| **Get favorites** `monday_get_favorites` | Retrieve all favorited items for the authenticated user |
| **Get folders** `monday_get_folders` | Retrieve folder data from workspaces with filtering and pagination options |
| **Get form** `monday_get_form` | Retrieve form metadata via the API using the form's unique token from the URL |
| **Get items** `monday_get_items` | Retrieve specific items by their IDs from Monday.com, returning metadata including name |
| **Get me** `monday_get_me` | Fetch the current authenticated user's profile and permissions |
| **Get mutation complexity** `monday_get_mutation_complexity` | Get complexity data of mutations in Monday.com |
| **Get query complexity** `monday_get_query_complexity` | Retrieve complexity data and cost metrics for Monday.com API operations |

## Example prompts

**Create an item on a board**

> List my boards with monday_boards, pick '\<board name>', then create an item with monday_create_item on that board, name '\<item name>', setting the \<column name> column value to '\<value>'. Confirm the item id.

**Create an item from a plain description**

> Use monday_create_item_from_nl to create an item on board '\<board name>' from this description: '\<description>'. Tell me which columns it filled in and what name it chose.

**Post an update on an item**

> Find the item '\<item name>' on board '\<board name>' with monday_get_items, then post the update '\<update text>' with monday_create_update. Confirm it landed.

## Monday.com tools vs monday's hosted MCP

The distinction searchers hit on the 'best MCP' query, stated with the checkable facts: monday's official server lives at https://mcp.monday.com/mcp, and this integration is a different, wider route for the same boards.

- **Item creation takes column values.** `monday_create_item` creates an item on a board, optionally assigning it to a group and setting column values, which is the tool-form of the GraphQL `create_item` mutation that manual guides teach.
- **There is a natural-language create tool.** `monday_create_item_from_nl` takes a plain description, fetches the board's column schema at runtime, fills the columns, and creates the item. It is the one tool in the set that hides monday's column-value JSON entirely.
- **Complexity is visible.** `monday_get_query_complexity` and `monday_get_mutation_complexity` return complexity data and cost metrics for API operations, which monday.com's GraphQL API tracks per account plan.
- **The toolset mirrors the GraphQL API.** `monday_boards`, `monday_columns`, `monday_get_items`, and `monday_create_update` map one-to-one onto monday's GraphQL query and mutation names, so the tool list doubles as a map of what the API can do.

## 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 Monday working from chat.

| | Manual | ClawLink |
|---|---|---|
| **Connection flow** | Register a Monday app, configure redirect URLs, manage consent details, and reconnect users when auth settings drift. | Users connect Monday 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 Monday. | 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 Monday actions to the runtime in a format your agent can reliably use. | 121 tools for Monday are already exposed through ClawLink, so the agent can read and act from chat immediately. |

## ClawLink vs. Composio

Composio also exposes Monday 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 Monday in the browser, and the 121 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 Monday
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 Monday 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 Monday tools
Monday 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 Monday 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.

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

### Monday.com API 403 insufficient permissions
monday.com's 403 causes, as taught by the engines and confirmed against the toolset: the connected account is not a member of the private board in the request; the account has read-only or guest rights where the tool needs more; the app is missing the scopes the action needs; or a workspace admin has restricted the connected account from creating integrations or API tokens. The last cause is the one this page did not previously list, and it is the one that produces a 403 on a healthy-looking connection. Also check the request itself: boards and items are addressed by id, so an example id from documentation fails exactly like a missing membership does. Run monday_boards first and retry with real ids from its results.

Ask the agent to diagnose it:

```text
Call monday_get_me and monday_boards to confirm the account and the boards it can see, then retry the failing call once and quote the exact error.
```

### Monday.com MCP tool not found
The fix search engines teach for this error is a workspace-level switch: Admin, then Permissions, then AI Connectors, with 'AI Connectors & MCP Access' enabled. That switch gates AI and MCP access for the whole workspace, so if it is off, a connected integration can look healthy and still fail to load tools. Have a workspace admin check it before assuming a connection problem. On the ClawLink hosted flow the analogous error is 'Tool schema not loaded yet', which clears on retry: schemas load on demand the first time a tool runs. Reconnect from the dashboard only if every call keeps failing in a fresh chat.

### OAuth finished in the browser but the account is still missing
Try reconnecting Monday 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 Monday integration?
Yes. ClawLink is the fastest way to connect Hermes to Monday: link your Monday account once in the browser and Hermes Agent can call the Monday API through 121 ready-made tools — no custom code or token handling.

### How do I connect Monday 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 Monday 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 Monday to Hermes Agent?
About two minutes. Sign in, click Connect next to Monday in the dashboard, authenticate, and Hermes Agent can use it from the next chat message.

### Why use ClawLink instead of wiring Monday 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 Monday working from chat.

### Do I need a monday.com API token to connect Hermes?
No. The connection uses hosted OAuth: you sign in to monday.com in the browser once and ClawLink stores the session server-side. You never open monday.com's developer console, never create a personal API token, and never paste one into a config file. The engine answer to this query currently teaches the manual token flow or monday's internal agents; the hosted-OAuth path for an external agent is what this page covers.

### What is the difference between monday.com Agent Builder and ClawLink?
Agent Builder and Agent Factory create agents that run inside monday.com and act on its boards natively, which is why those answers can say no API key is involved. ClawLink connects an agent that already runs outside monday: Hermes Agent. The agent stays in its own runtime and reaches monday through hosted OAuth, with 121 tools covering boards, items, columns, updates, and documents. If your agent is Hermes, ClawLink is the connector; if you want a monday-internal agent, use monday's own builder.

### What is the AI Connectors and MCP Access setting?
It is a workspace admin toggle on monday.com: Admin, then Permissions, then AI Connectors, then 'AI Connectors & MCP Access' on. Search engines teach this switch as the fix when monday tools fail to load, and it matters for a hosted connection too: if the workspace has AI connector access disabled, connected integrations can be blocked at the workspace level no matter what your account permissions say. If tools fail to appear after connecting, ask a workspace admin whether that toggle is on.

### Is it safe to connect monday.com to an AI agent?
The connection is scoped OAuth: your agent can do what your monday.com account can do, including nothing on boards you are not a member of, and the connection is revocable from the ClawLink dashboard at any time. monday.com's own security answers (permission scoping, private boards) apply as they would to any authorized app, because the agent is exactly that: an authorized app acting under your account's permissions. Connect with the account whose permissions you intend the agent to have.

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

- [Connect DocuSign](https://claw-link.dev/hermes/docusign) — Send, sign, and manage agreements and envelopes
- [Hermes Moco integration](https://claw-link.dev/hermes/moco) — MOCO is a business management software offering project management, time tracking, and invoicing solutions.
- [Wrike](https://claw-link.dev/hermes/wrike) — Manage projects, tasks, and team workflows at scale