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

> Connect Google Classroom to Hermes with ClawLink in one click — 62 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-classroom

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

1. **Install ClawLink** — add the plugin to Hermes Agent once.
2. **Connect Google Classroom** — 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-classroom  # connect Google Classroom (browser OAuth)
npx -y @useclawlink/cli actions google-classroom  # list available actions
npx -y @useclawlink/cli run google-classroom <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 Classroom 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 courses with google_classroom_courses_list, then for each one pull coursework with google_classroom_course_work_list. Show me everything with a due date in the next week, grouped by course.

### 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 Classroom is connected in the dashboard, that agent calls the same 62 Google Classroom 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 Classroom MCP for Hermes

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

Hermes Agent has no built-in Google Classroom integration, and the answers you will find teach one of two things: a Composio CLI walkthrough with an MCP config file, or a Google Cloud project with a service account and domain-wide delegation. This is the shorter route. Install the plugin with `hermes plugins install ClawLink-HQ/hermes-plugin --enable`, pair once with `hermes clawlink begin` and `hermes clawlink finish`, then connect Google Classroom in the ClawLink dashboard, and Hermes can call the 62 Classroom tools below. Worth saying plainly because the open-source Classroom servers set the expectation otherwise: this toolset is not read-only — it can create coursework, post materials, manage topics, and read student submissions, subject to what your Classroom role allows.

## What the Hermes Agent Google Classroom integration can do

62 Google Classroom 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 62.

### 30 of 62 Google Classroom tools for Hermes

| Tool | What it does |
|---|---|
| **Course work create** `google_classroom_course_work_create` | Tool to create a CourseWork item in a course. Use when you need to assign an assignment or question to students immediately or on a schedule. |
| **Course work get** `google_classroom_course_work_get` | Tool to get details of a specific coursework. Use when detailed information about a particular assignment is needed. |
| **Course work list** `google_classroom_course_work_list` | Tool to list coursework in a course. Use after verifying courseId. |
| **Course work materials create** `google_classroom_course_work_materials_create` | Tool to create course work material. Use when adding resources or notes to a course. |
| **Course work materials get** `google_classroom_course_work_materials_get` | Tool to get a coursework material. Use when you need to retrieve details of a specific coursework material by course and material ID. |
| **Course work materials list** `google_classroom_course_work_materials_list` | Tool to list course work materials in a course. Use when you need to retrieve and paginate materials for a given courseId. |
| **Course work student submissions list** `google_classroom_course_work_student_submissions_list` | Tool to list student submissions for a specific coursework. Use when you need to fetch or paginate student submissions by course and coursework, optionally filtering by user, state, or timeliness. |
| **Course work student submissions reclaim** `google_classroom_course_work_student_submissions_reclaim` | Tool to reclaim a student submission for editing. Use after a student requests to edit their turned-in submission, resetting its state to CREATED. |
| **Courses aliases create** `google_classroom_courses_aliases_create` | Tool to create an alias for a course. Use when you need to add an alternative identifier to a course after confirming the course ID. |
| **Courses aliases list** `google_classroom_courses_aliases_list` | Tool to list aliases for a course. Use when you need to retrieve all aliases associated with a specific course. |
| **Courses announcements get** `google_classroom_courses_announcements_get` | Get an announcement |
| **Courses announcements get add on context** `google_classroom_courses_announcements_get_add_on_context` | Get metadata for Classroom add-ons in the context of a specific announcement post |
| **Courses announcements list** `google_classroom_courses_announcements_list` | List announcements in a course |
| **Courses announces add on attachs get** `google_classroom_courses_announces_add_on_attachs_get` | Get an add-on attachment from an announcement |
| **Courses announces add on attachs list** `google_classroom_courses_announces_add_on_attachs_list` | List all add-on attachments created under an announcement |
| **Courses course work get add on context** `google_classroom_courses_course_work_get_add_on_context` | Get metadata for Classroom add-ons in the context of a specific course work |
| **Courses course work materials add attachs** `google_classroom_courses_course_work_materials_add_attachs` | List all add-on attachments under a course work material post |
| **Courses coursework rubrics list** `google_classroom_courses_coursework_rubrics_list` | List rubrics for a specific coursework |
| **Courses get** `google_classroom_courses_get` | Get details for a specific course |
| **Courses get grading period settings** `google_classroom_courses_get_grading_period_settings` | Retrieve grading period settings for a course |
| **Courses list** `google_classroom_courses_list` | List all courses accessible to the authenticated user |
| **Courses posts add on attachments list** `google_classroom_courses_posts_add_on_attachments_list` | List all add-on attachments created under a post |
| **Courses posts get add on context** `google_classroom_courses_posts_get_add_on_context` | Get metadata for Classroom add-ons in the context of a specific post |
| **Courses students get** `google_classroom_courses_students_get` | Retrieve a specific student of a course |
| **Courses students guardians list** `google_classroom_courses_students_guardians_list` | List guardians of a student in a course |
| **Courses students list** `google_classroom_courses_students_list` | List students in a course |
| **Courses teachers get** `google_classroom_courses_teachers_get` | Get teacher enrollment |
| **Courses teachers list** `google_classroom_courses_teachers_list` | List teachers in a course |
| **Courses topics get** `google_classroom_courses_topics_get` | Get a course topic |
| **Courses topics list** `google_classroom_courses_topics_list` | List topics in a course |

## Example prompts

**See what's outstanding across courses**

> List my courses with google_classroom_courses_list, then for each one pull coursework with google_classroom_course_work_list. Show me everything with a due date in the next week, grouped by course.

**Create an assignment**

> In the course "\<course>", create coursework titled "\<title>" with google_classroom_course_work_create, description from the notes above, due \<date>. Show me the payload before you create it.

**Check who has submitted**

> For the coursework "\<title>" in "\<course>", use google_classroom_course_work_student_submissions_list to tell me who has turned it in and who has not. Do not change any submission states.

**Post course materials**

> Add the reading list above to "\<course>" as course materials with google_classroom_course_work_materials_create, titled "\<title>". Show it to me before posting — students will see it immediately.

## How the Google Classroom tools behave

Classroom's own rules do most of the work here, and they explain nearly every surprising result.

- **Your role on each course is the real permission boundary.** The same connection can read one course fully and none of another. `google_classroom_courses_list` is the first diagnostic for anything permission-shaped.
- **Submissions are addressed per coursework item.** `google_classroom_course_work_student_submissions_list` needs both the course id and the coursework id, so listing coursework comes first.
- **Coursework and materials are different objects.** `google_classroom_course_work_create` posts assignments; `google_classroom_course_work_materials_create` posts reference material with no submission attached. Asking for the wrong one produces something students cannot turn in, or an assignment where you meant a handout.
- **Courses can be addressed by alias as well as id.** `google_classroom_courses_aliases_list` and `..._create` manage those, which is useful when integrating with a school information system that has its own identifiers.
- **Writes are immediately visible to students.** Announcements, coursework, and materials appear in the course as soon as they are created, so review before posting rather than after.
- **Guardian data is reachable and sensitive.** `google_classroom_courses_students_guardians_list` returns guardian contacts. Treat it as the most restricted thing in the toolset.

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

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

## ClawLink vs. Composio

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

### Google Classroom returns 403 or "The caller does not have permission" on one course
Classroom's permission model is per-course and role-based, and that is almost always what this is. The connected account has to hold a role on the specific course for the action attempted: reading a course roster or student submissions requires being a teacher on it, and an account that is a teacher on some courses and not others will succeed and fail in exactly this pattern. That is Classroom enforcing course boundaries rather than a scope problem, and no reconnection changes it — the fix is the account's role on that course. Two other causes are worth ruling out. On a managed Workspace domain, an admin policy may block third-party app authorization entirely, which shows up at connect time rather than per course. And a course id copied from documentation fails as a permission error rather than a not-found, so have the agent list courses and use a real id.

Ask the agent to diagnose it:

```text
Run google_classroom_courses_list and tell me exactly which courses this connection can see and what role the account holds on each. Do not retry the failed call yet.
```

### "Course not found" for a course you can open in Classroom yourself
Usually the account, sometimes the identifier. Teachers and students routinely hold a personal Google account and a school one, and the courses the agent sees belong to whichever account approved the grant — a connection made with the wrong one looks healthy and finds nothing. The identifier cause is that courses can be addressed by id or by an alias, and an alias that was never created does not resolve. Have the agent run google_classroom_courses_list first and work from the ids it returns; google_classroom_courses_aliases_list shows which aliases exist if you rely on them.

Ask the agent to diagnose it:

```text
Tell me which Google account this connection is acting as, then run google_classroom_courses_list and show me every course with its id and your role on it.
```

### Student submissions come back empty for coursework that clearly has them
Two boundaries produce an empty list rather than an error. The first is role: only a teacher on that course can list other people's submissions, so a student account sees only its own, and a connection made with the wrong account returns nothing without complaining. The second is scope of the query — google_classroom_course_work_student_submissions_list is per coursework item, so it needs the course id and the coursework id, and an agent that has only the course id will not find submissions by guessing. Ask it to list coursework with google_classroom_course_work_list first and then pull submissions for the specific item.

Ask the agent to diagnose it:

```text
Run google_classroom_course_work_list for the course and show me each coursework item with its id. Then list submissions for the one I name, and tell me what role you hold on that course.
```

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

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

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

### Does Hermes have a Google Classroom integration?
Not built in, which is why the question has an unhelpful answer almost everywhere. Hermes Agent ships without Classroom tools, so the integration has to come from somewhere, and the usual suggestions are a self-hosted MCP server with a Google Cloud project behind it, or a service account with domain-wide delegation arranged by your Workspace admin. Connecting through ClawLink is the one-step version: you approve Classroom on Google's consent screen and the tools are available in the next message, with no Cloud project and no config file.

### What can the agent do — is it read-only?
No, and this is where the open-source options set a misleading expectation. Several community Classroom servers are read-only by design, so summaries of the space describe agent access to Classroom as reading courses and rosters. This toolset covers creating and reading coursework, posting course materials and announcements, listing and reclaiming student submissions, managing topics and aliases, reading rosters of students and teachers, listing guardians, and reading rubrics and grading-period settings. What it can actually do in your Classroom is then bounded by your role, not by the tool list.

### Do I need to be a teacher, and does my admin need to approve anything?
Your Classroom role decides what the agent can do, because the agent acts as you. A teacher on a course can create coursework and read submissions for it; a student sees their own work; someone with no role on a course sees nothing, which is Classroom working correctly rather than a broken connection. Separately, some Workspace domains restrict which third-party apps users may authorize at all, so on a managed school or district account an admin may need to allow the connection before the consent screen will complete. That is a Workspace policy question rather than anything configurable in ClawLink.

### Is it safe to connect Google Classroom to an AI agent?
The connection uses Google's OAuth consent flow, so you approve it on Google's screen, no password is handled, and disconnecting from the ClawLink dashboard ends access. Classroom deserves more care than most integrations for a reason that is not technical: the data includes student names, submissions, and guardian contacts, so the sensible defaults are to connect the account whose role you intend the agent to have, to keep a human in the loop before anything is posted to a course, and to be deliberate about asking an agent to summarize or move student work at all. Student data protection rules that apply to your institution apply to the agent's use of it too.

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

- [Google Super](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