# How to connect Google Calendar to Hermes Agent (no API keys)

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

Web version: https://claw-link.dev/hermes/google-calendar

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

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

Verify the connection by asking Hermes:

> Use Google Calendar to googlecalendar create event and walk me through the result in plain English.

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

## Google Calendar MCP for Hermes

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

Every documented route to Google Calendar in Hermes Agent starts in the Google Cloud Console: create a project, enable the Calendar API, create a Desktop OAuth client, download the client secret JSON, then run an auth command and paste a redirect URL back into the terminal. The official Google Workspace skill also connects Gmail, Drive, Sheets and Docs in the same grant, so calendar-only access is not really on offer. ClawLink removes the Cloud project entirely: you approve Google's own consent screen in the browser, and Hermes calls the 44 Google Calendar tools from the next message. There is no client secret on your machine and no token file to keep alive.

## What the Hermes Agent Google Calendar integration can do

44 Google Calendar 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 44.

### 30 of 44 Google Calendar tools for Hermes

| Tool | What it does |
|---|---|
| **Create event** `googlecalendar_create_event` | Create a Google Calendar event |
| **Duplicate calendar** `googlecalendar_duplicate_calendar` | Duplicate a Google Calendar |
| **Events get** `googlecalendar_events_get` | Get a Google Calendar event by event id |
| **Events instances** `googlecalendar_events_instances` | List instances of a recurring Google Calendar event |
| **Events list** `googlecalendar_events_list` | List events from a Google Calendar |
| **Events move** `googlecalendar_events_move` | Move a Google Calendar event to another calendar |
| **Find event** `googlecalendar_find_event` | Find a Google Calendar event |
| **Find free slots** `googlecalendar_find_free_slots` | Find free time slots across calendars |
| **Get calendar** `googlecalendar_get_calendar` | Get Google Calendar metadata by calendar id |
| **Get current date time** `googlecalendar_get_current_date_time` | Get current date and time with timezone context |
| **List calendar resources** `googlecalendar_list_calendar_resources` | List calendar resources (rooms/equipment) |
| **List calendars** `googlecalendar_list_calendars` | List Google Calendars available to the connected account |
| **Patch event** `googlecalendar_patch_event` | Patch a Google Calendar event |
| **Quick add** `googlecalendar_quick_add` | Create a Google Calendar event from a natural language description |
| **Update event** `googlecalendar_update_event` | Update a Google Calendar event |
| **Acl get** `googlecalendar_acl_get` | Retrieves a specific access control rule for a calendar |
| **Acl list** `googlecalendar_acl_list` | Retrieves the list of access control rules (ACLs) for a specified calendar, providing the |
| **Calendar list get** `googlecalendar_calendar_list_get` | Retrieves metadata for a SINGLE specific calendar from the user's calendar list by its calendar |
| **Colors get** `googlecalendar_colors_get` | Returns the color definitions for calendars and events |
| **Events list all calendars** `googlecalendar_events_list_all_calendars` | Return a unified event list across all calendars in the user's calendar list for a given time |
| **List buildings** `googlecalendar_list_buildings` | Lists all buildings for a Google Workspace customer account with full details including |
| **Settings get** `googlecalendar_settings_get` | Return a single user setting for the authenticated user |
| **Settings list** `googlecalendar_settings_list` | Returns all user settings for the authenticated user |
| **Acl insert** `googlecalendar_acl_insert` | Creates an access control rule for a calendar |
| **Acl patch** `googlecalendar_acl_patch` | Updates an existing access control rule for a calendar using patch semantics (partial update) |
| **Acl update** `googlecalendar_acl_update` | Updates an access control rule for the specified calendar |
| **Acl watch** `googlecalendar_acl_watch` | Watch for changes to ACL resources |
| **Calendar list insert** `googlecalendar_calendar_list_insert` | Inserts an existing calendar into the user's calendar list, making it visible in the UI |
| **Calendar list patch** `googlecalendar_calendar_list_patch` | Updates an existing calendar on the user's calendar list using patch semantics |
| **Calendar list update** `googlecalendar_calendar_list_update` | Updates a calendar list entry's display/subscription settings (color, visibility, reminders |

## Example prompts

**Googlecalendar Create Event**

> Use Google Calendar to googlecalendar create event and walk me through the result in plain English.

**Googlecalendar Duplicate Calendar**

> Use Google Calendar to googlecalendar duplicate calendar and walk me through the result in plain English.

**Googlecalendar Events Get**

> Use Google Calendar to googlecalendar events get and walk me through the result in plain English.

**Googlecalendar Events Instances**

> Use Google Calendar to googlecalendar events instances and walk me through the result in plain English.

## Google Calendar tool names and arguments Hermes gets wrong

These are the failures we actually see in production, with argument names and limits read from the live tool schemas. An agent will usually guess wrong on the first call, and two of these fail silently rather than erroring.

- **The tool names read verb last, which is the opposite of every other Google Calendar MCP.** Listing events is `googlecalendar_events_list`. The community server `@cocal/google-calendar-mcp` calls it `list-events`, Google's own `calendarmcp.googleapis.com` calls it `list_events`, and so does the `v-3/google-calendar` server. A model that has seen any of those writes `googlecalendar_list_events` and gets nothing back; that single wrong name is the most common miss we log. The same pattern applies to `googlecalendar_patch_event` (not `events_patch`) and `googlecalendar_calendar_list_get` (not `calendar_list_list`). Ask Hermes to run `clawlink_list_tools` once and it will use the real names.
- **`googlecalendar_events_list` with only a `calendarId` returns your whole calendar history, not your upcoming events.** No time filter is applied by default. A real production call with the arguments `\{"calendarId": "primary"\}` came back with 249 events whose start dates ran from 2015-03-10 to 2024-03-28, because Google caps the unfiltered response at 250 and that account's oldest events filled it. The agent then summarises a decade-old week and reports that you have nothing coming up. Always pass `timeMin`, and add `singleEvents: true` with `orderBy: "startTime"` so recurring events expand and sort correctly.
- **Time and calendar arguments change case between tools.** `googlecalendar_events_list` wants `calendarId`, `timeMin` and `timeMax` in camelCase, while `googlecalendar_create_event` and `googlecalendar_patch_event` want `calendar_id` in snake_case and `googlecalendar_events_list_all_calendars` wants `time_min`. Copying arguments from one call into the next is why we log both `arguments.calendarId is required` and `arguments.calendar_id is required` against the same integration.
- **`start_datetime` is the only required argument on `googlecalendar_create_event`, and it is a flat string, not Google's nested `start` object.** Google's own API reference documents `\{"start": \{"dateTime": "..."\}\}`, so a model reaching for training data sends that and the call fails with `arguments.start_datetime is required`. Send `start_datetime: "2026-08-14T13:00:00"` and put the zone in the separate `timezone` argument.
- **There is no `end_datetime` argument, and passing one does not error.** Duration comes only from `event_duration_hour` and `event_duration_minutes`, so "book 2pm to 4pm" sent as a start plus an end silently creates a 30 minute event at 2pm. This is the quietest failure on the toolkit: the call returns success and the calendar is simply wrong.
- **`event_duration_minutes` accepts 0 to 59 only.** Anything an hour or longer goes in `event_duration_hour` (0 to 24), so 90 minutes is `event_duration_hour: 1` plus `event_duration_minutes: 30`. Passing 90 fails with `Input should be less than or equal to 59`. Omit both and you get 30 minutes.
- **`attendees` takes plain email strings, and an object only to mark someone optional.** `["sam@acme.com"]` is the normal form; the mixed form `["sam@acme.com", \{"email": "kim@acme.com", "optional": true\}]` is what the tool documents for optional guests. The live schema types the items as strings, so keep to bare strings unless you specifically need the optional flag.
- **Every event you create gets a Google Meet link unless you switch it off.** Leaving `create_meeting_room` out produced a `hangoutLink` on all three of our test calls, and only `create_meeting_room: false` suppressed it. Ask for a quiet hour of focus time and you get a joinable meeting room on it, which is worth knowing before the invite goes to attendees. The tool description warns that conferencing needs a paid Google Workspace account and that personal accounts fail with `Invalid conference type value`; the account we tested this on is a personal Gmail account and the link was created every time.
- **Two tools named in the tool descriptions do not exist on ClawLink.** `googlecalendar_calendar_list_get` tells the agent to "use GOOGLECALENDAR_CALENDAR_LIST_LIST instead" to list calendars, and `googlecalendar_create_event` points at `GOOGLECALENDAR_FREE_BUSY_QUERY` for conflict checking. Neither is among the 44 tools here, so an agent that follows the instruction gets a not-found error through no fault of its own. Use `googlecalendar_list_calendars` for the first and `googlecalendar_find_free_slots` for the second.
- **There is a `googlecalendar_get_current_date_time` tool, and agents that skip it get relative dates wrong.** "Next Tuesday" is computed from whatever the model believes today is, which is why wrong-date complaints usually trace back to a missing current-time call rather than to the calendar.

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

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

## ClawLink vs. Composio

Composio also exposes Google Calendar 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 Google Calendar in the browser, and the 44 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 Google Calendar
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 Google Calendar 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 Google Calendar tools
Google Calendar 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 Google Calendar 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.

### Google Calendar 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.

### Hermes says your calendar is empty, or answers with events from years ago
The connection is fine and the call succeeded; the agent just asked for everything. `googlecalendar_events_list` applies no time filter unless you give it one, and Google caps an unfiltered response at 250 events. On an account with a long history those 250 slots fill with the oldest events, so the agent receives a page of meetings from years back, finds nothing near today, and tells you the calendar is empty. We have a production call that returned 249 events dated 2015 to 2024 from the arguments `\{"calendarId": "primary"\}` alone. The fix is to bound the window rather than to reconnect anything.

Ask the agent to diagnose it:

```text
Re-run the calendar lookup, but first call googlecalendar_get_current_date_time, then call googlecalendar_events_list with timeMin set to today, timeMax set to seven days out, singleEvents true and orderBy startTime. Show me the exact arguments before you send them.
```

### Tool 'googlecalendar_list_events' not found
The tool exists under a different name. ClawLink's Google Calendar tools read verb last, so it is `googlecalendar_events_list`, not `list_events`. This trips agents because every other Google Calendar MCP server uses the opposite order: `list-events` on `@cocal/google-calendar-mcp` and `list_events` on Google's own calendarmcp endpoint. The same applies to `googlecalendar_patch_event` rather than `events_patch`. One case is not the agent's fault at all: the description on `googlecalendar_calendar_list_get` says to "use GOOGLECALENDAR_CALENDAR_LIST_LIST instead" for listing calendars, and that tool is not exposed here, so following the instruction fails. The tool you want is `googlecalendar_list_calendars`. ClawLink returns a "Did you mean" line with the closest matches on every miss, so tell the agent to read that line instead of inventing another variant.

Ask the agent to diagnose it:

```text
Run clawlink_list_tools for google-calendar and show me the exact tool names it returns. Then retry using a name from that list, not a guess.
```

### arguments.start_datetime is required
The agent sent Google Calendar API's nested shape, `\{"summary": "...", "start": \{"dateTime": "2026-08-14T13:00:00Z"\}, "end": \{"dateTime": "..."\}\}`. That is exactly what Google's reference documents, so models write it from memory, but this tool takes flat arguments: the nested `start` is ignored and the required `start_datetime` really is missing. Retrying the same payload cannot fix it. The working form is `start_datetime: "2026-08-14T13:00:00"` with `timezone` set separately, and the length expressed as `event_duration_hour` and `event_duration_minutes` instead of an end time.

Ask the agent to diagnose it:

```text
Retry the event creation and show me the arguments first. start_datetime must be a flat string like 2026-08-14T13:00:00, the zone goes in timezone, and the length goes in event_duration_hour and event_duration_minutes. Do not send a start or end object.
```

### arguments.time_min is required
This one comes from `googlecalendar_events_list_all_calendars`, which takes snake_case `time_min` and `time_max`, while the single-calendar `googlecalendar_events_list` takes camelCase `timeMin` and `timeMax`. An agent that succeeded on one and then switched tools carries the wrong casing across and the required argument reads as absent. Give it the window in the casing the tool it is calling actually wants.

Ask the agent to diagnose it:

```text
You are calling googlecalendar_events_list_all_calendars, which needs time_min and time_max in snake_case. Show me the arguments with that casing before sending.
```

### Request had insufficient authentication scopes.
ClawLink asks Google for `https://www.googleapis.com/auth/calendar` and `https://www.googleapis.com/auth/calendar.events`, which covers every tool on this page. A 403 with this message means the token you actually granted is narrower than what was requested, which happens when a permission checkbox is cleared on Google's consent screen or the flow is completed against a different account partway through. Note that the usual advice for this error does not apply here: there is no `token.json` or local token cache to delete, because ClawLink holds the grant server side. Reconnect Google Calendar from the dashboard and approve every permission Google asks for. It is rare, four occurrences across 8,567 production Google Calendar calls, so check the calendar id first if events are simply missing.

Ask the agent to diagnose it:

```text
Tell me which Google account is connected and which calendar id you are calling. If the account is right, I will reconnect Google Calendar and approve every checkbox on the consent screen.
```

### Connected account is not in an ACTIVE state. Current status is "REVOKED"
The Google grant was withdrawn on Google's side, not on ours, so the credential is gone rather than expired. This happens when someone removes ClawLink at myaccount.google.com/permissions, when a Workspace admin revokes third-party access, or when the password changes on an account with that policy. Nothing retries its way out of it. Reconnect Google Calendar in the dashboard and the same tools resume; if the status reads INITIALIZING instead, an OAuth flow was started and never finished, so complete the consent screen in one browser session.

Ask the agent to diagnose it:

```text
Stop retrying. Tell me the connection status you are seeing for google-calendar and wait; I need to reconnect the account in the ClawLink dashboard before this can work.
```

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

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

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

### Do I need a Google Cloud project to connect Google Calendar to Hermes Agent?
Not with ClawLink. The official Hermes Google Workspace skill and the third-party guides all start by creating a Google Cloud project, enabling the Calendar API, creating a Desktop OAuth client and downloading a client secret JSON. ClawLink runs that OAuth application for you, so you approve Google's own consent screen in the browser and Hermes can call Google Calendar from the next message. No Cloud project, no client secret on your machine, and nothing to keep running.

### What Google Calendar permissions does ClawLink actually request?
Two scopes: `https://www.googleapis.com/auth/calendar` and `https://www.googleapis.com/auth/calendar.events`. That is enough to read, create, edit and delete events on the calendars the connected account can reach, and we would rather name it than describe it as narrower than it is. What it avoids is a standing credential: there is no client secret or token file on your machine, the grant appears under Third-party apps and services in your Google account, and one click at myaccount.google.com/permissions ends it. If that reach is more than you want on a personal calendar, connect a secondary Google account and share into it only the calendars Hermes should see.

### Why does Hermes give me the wrong dates from Google Calendar?
Two causes, and neither is the connection. If the answer is about events from years ago or Hermes claims the calendar is empty, the listing call went out with no time window, and Google returns the calendar's history capped at 250 events rather than what is coming up. If the answer is off by a few days, the agent worked out "next Tuesday" from the date it assumed rather than today's. Ask it to call `googlecalendar_get_current_date_time` first, then list events with an explicit `timeMin` and `timeMax`.

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

- [Hermes Google Super integration](https://claw-link.dev/hermes/google-super) — Unified access to multiple Google services in one integration
- [Hermes Google Drive integration](https://claw-link.dev/hermes/google-drive) — Upload, search, and manage files
- [Connect Google Analytics](https://claw-link.dev/hermes/google-analytics) — Connect Google Analytics properties through hosted Google OAuth