Teach Your Agent a New Trick

Author a custom skill that gives your agent a multi-system weekly review workflow.

Introduction

30 Second Summary

Every Friday you sit down and try to remember what you actually accomplished that week. The commits blur together, meetings fade, and email threads pile up. You end up staring at a blank page.

In this project, you will teach your Hermes Agent a brand-new skill that pulls your GitHub commits, calendar meetings, and email threads into a polished weekly review. Then you will schedule it to run autonomously every Friday and deliver the result to your phone.

What You'll Build

You tell your agent "Run my weekly review" from your phone, and it pulls your GitHub commits and PRs from the past week, cross-references them with your calendar meetings and email threads, and writes a structured summary of what you shipped, what you discussed, and what is coming next.

By the end of this project, you'll have:

  • A live GitHub connection via MCP where you ask your agent about issues, PRs, and commits in natural language and get real answers from your real repos.
  • A hand-authored SKILL.md that teaches your agent a multi-system workflow it did not know before, persisted permanently in your skills directory.
  • A scheduled Friday cron job that runs your skill autonomously and delivers a formatted weekly review to your phone via Hermex.
  • Secret Mission: Chain a second cron job that transforms your weekly review into a professional highlights email and stages it as a Gmail draft every Friday evening.

Are there any prerequisites?

This project picks up where "Connect Your Agent to Gmail and Calendar" left off. You need a working Hermes Agent with Hermes WebUI, Tailscale, Hermex, and the Google Workspace skill (Gmail + Calendar) already set up and running.

You also need a GitHub account and Node.js installed (required for the MCP server subprocess).

Before We Start

Before We Start...

Before we dive in, let's lock in what you're about to build and why it matters. You've connected your agent to Gmail and Calendar and talked to it from your phone. Now you're going to teach it something new: a skill that coordinates across all your connected systems and runs on its own.

Connect GitHub to Your Agent via MCP

Your agent can talk to Gmail and Calendar, but right now it has zero visibility into your code activity. Commits, pull requests, open issues are all invisible.

Without GitHub data, any "weekly review" would be missing half the picture. In this step, you'll connect GitHub to your agent through MCP so it can query your real repositories through natural language.

In this step, get ready to:
  • Create a GitHub Personal Access Token for your agent.
  • Add the GitHub MCP server to your Hermes config.
  • Verify the connection by querying your real repos.
Create a GitHub Personal Access Token

Your agent needs credentials to access your GitHub repositories. A Personal Access Token (PAT) acts as a password that grants specific permissions without exposing your full GitHub account.

  • Open https://github.com/settings/tokens in your browser.
  • Select Generate new token, then click Generate new token (classic).
  • In the Note field, enter Hermes Agent.
  • Under Expiration, choose an expiration window that suits you (or select No expiration for a permanent token).
  • Under Scopes, check the repo checkbox. This grants full control of private repositories.
  • Click Generate token at the bottom of the page.
  • Copy the token immediately. You will not be able to see it again after leaving this page.

Why a classic token instead of fine-grained?

GitHub recommends fine-grained tokens for new integrations. However, the MCP GitHub server currently requires a classic token with the repo scope to access repository data.

If you only want your agent to see public repositories, select public_repo instead of repo.

Token disappeared after navigating away?

GitHub only shows the token value once, at the moment of creation. If you navigated away before copying it, delete the token from your list and create a new one following the same steps above.

help me create a new GitHub Personal Access Token

Add the GitHub MCP server to your Hermes config

Now you'll tell Hermes how to launch the GitHub MCP server as a subprocess. This config entry defines the command, authentication, and which tools your agent can use.

  • Open your Hermes config file by running:
nano ~/.hermes/config.yaml
  • Add the following block under mcp_servers (create the key if it does not exist yet):
mcp_servers:
  github:
    command: "npx"
    args: ["-y", "@modelcontextprotocol/server-github"]
    env:
      GITHUB_PERSONAL_ACCESS_TOKEN: "your-token-here"
    tools:
      include: [list_issues, get_issue, create_issue, search_repositories, list_commits, get_pull_request, list_pull_requests]
      prompts: false
      resources: false

What does this config do?

  • command and args tell Hermes to launch the GitHub MCP server using npx. The -y flag auto-confirms the package download.
  • env passes your token to the server process so it can authenticate with GitHub's API.
  • tools.include restricts which MCP tools your agent can call. This keeps the tool list focused and avoids overwhelming the agent with unused capabilities.
  • prompts: false and resources: false disable MCP features your agent does not need for this workflow.
  • Replace your-token-here with the Personal Access Token you copied from GitHub.
  • Save and exit nano by pressing Ctrl+X, then Y, then Enter.

✔️ Awesome, I've got everything!

Great. Double check you saved your file before moving on.

ⓧ I'd like to double check the full code

Your mcp_servers section should look exactly like this (with your real token in place of the placeholder):

mcp_servers:
  github:
    command: "npx"
    args: ["-y", "@modelcontextprotocol/server-github"]
    env:
      GITHUB_PERSONAL_ACCESS_TOKEN: "your-token-here"
    tools:
      include: [list_issues, get_issue, create_issue, search_repositories, list_commits, get_pull_request, list_pull_requests]
      prompts: false
      resources: false

Not sure where to put the mcp_servers block?

If your config.yaml already has other top-level keys (like model or skills), add mcp_servers at the same indentation level. Make sure it is not nested inside another key.

YAML is whitespace-sensitive. Use exactly 2 spaces per indent level. Tabs will cause parse errors.

help me fix my Hermes config.yaml for the GitHub MCP server

Restart Hermes and verify the connection

Hermes reads its config at startup. You need to restart it for the new MCP server to become available.

  • Stop your running Hermes WebUI process (Ctrl+C in the terminal where it is running).
  • Restart it by running ./start.sh again from your hermes-webui directory.
  • Open the Hermes WebUI at http://localhost:8787 in your browser.
  • Start a new session by clicking New Session.

Before you test, think about this: if the MCP connection is working, what kind of data should your agent be able to return when you ask about a repository?

  • Type the following message in your Hermes session (replace with your own GitHub username and repository name):
List the open issues in [[GITHUB_REPO="your-username/your-repo-name"]]

Your agent should return real issue titles and numbers from your repository. If you see actual data from your GitHub repo, the MCP connection is working.

What if my repo has no open issues?

If the repository has no open issues, the agent will report that. That still confirms the connection is working. You can also try asking about commits or pull requests instead.

Seeing an error about the MCP server?

  • Check that Node.js and npx are installed by running npx --version in your terminal. The MCP server launches as an npx subprocess.
  • Verify your token has the repo scope. A token with no scopes cannot access private repository data.
  • Check your YAML indentation. Open ~/.hermes/config.yaml and confirm that github is indented under mcp_servers, and all nested keys use 2-space indentation.

help me debug my GitHub MCP server connection in Hermes

Your agent now has live access to your GitHub repos. Next up, you'll explore what it can actually do with this data and discover the gap that your custom skill will fill.

Talk to Your Repo

Your agent can now reach into GitHub and pull live data. In Step 1, you proved the connection works by listing issues.

Now you need to see what the MCP tools actually return. Before you author a skill, you need to understand the raw data your skill will work with. You also need to see what happens when you ask the agent to combine data across systems without any guidance.

In this step, get ready to:
  • Query your GitHub activity through natural language and observe the structured data returned.
  • Combine GitHub and Google Calendar in a single multi-system query.
  • Confirm the gap: your agent can access everything but cannot synthesize it into a useful review.
Explore your GitHub activity through natural language

Your agent has access to seven GitHub tools through MCP. Each tool returns structured data: commit SHAs, author names, timestamps, PR statuses, and more. Seeing this raw data tells you exactly what a future skill can work with.

  • In the Hermes WebUI session you already have open, type this message and send it:
Show me the last 5 commits on [[REPO_NAME="your-github-username/your-repo-name"]]
  • Observe the response. Your agent returns commit SHAs, commit messages, author names, and timestamps for each commit.
  • Now send this message:
List my open pull requests on [[REPO_NAME="your-github-username/your-repo-name"]]
  • You should see PR titles, numbers, statuses, and authors pulled directly from your repository.
  • Try one more query to search across your repos:
Search my GitHub repos for [[KEYWORD="a keyword relevant to your projects"]]

What structured data should I see?

Each query should return real data from your GitHub account, not placeholders or examples. Commits show SHAs, messages, authors, and dates. PRs show titles, numbers, open/closed/merged status, and reviewers.

This structured data is what your MCP tools expose. A skill you write later can instruct the agent to pull exactly this data and reshape it into something meaningful.

Not seeing real data from your repos?

Make sure you are using your actual GitHub username and repository name. The format is username/repo-name.

If you get a permissions error, your Personal Access Token may not have the repo scope. Regenerate a token with the correct scope and update ~/.hermes/config.yaml.

help me debug why my GitHub MCP queries return errors or empty results

Combine GitHub with Gmail and Calendar

Your agent already has access to Gmail and Calendar through the Google Workspace skill you set up in the previous project. The real power is combining data from multiple systems in a single query.

  • Send this multi-system query to your agent:
Show me my GitHub commits from the last 7 days AND my calendar events for this week
  • Your agent pulls from both GitHub (via MCP) and Google Calendar (via the Google Workspace skill) in a single response.

Look at the output carefully. The agent dumps both data sets, but it does not analyze them or draw connections between them. It is raw information without narrative.

Why is the output unstructured?

Your agent executed both tool calls successfully. It can access any system you have connected. But it has no instructions for how to combine that data into something useful.

It does not know which commits relate to which meetings. It does not prioritize or summarize. It just shows everything it found. This is the limitation your custom skill will fix in the next step.

Confirm the gap

You have seen your agent pull data from GitHub, Gmail, and Calendar individually and together. Now ask it for the thing you actually want: a weekly review of your work.

  • Before you send the next message, predict what you think the agent will produce. Will it check all three systems on its own? Will it format a clean summary with sections? Or will it do something else?
  • Send this message:
Give me a weekly review of my work

The agent produces something generic or asks clarifying questions. It does not know your preferred format, what systems to check, or how to structure the output.

Why is this the expected result?

Your agent can access everything. It has GitHub, Gmail, and Calendar all connected. But "give me a weekly review" is vague from the agent's perspective.

It does not know to check all three systems automatically. It does not know what format you want. It does not know which emails matter and which are noise. A skill teaches it all of this as a permanent, reusable procedure.

This is the problem. Your agent has all the access it needs but none of the procedural knowledge to combine it into something useful. That gap is exactly what you will fix next by authoring a custom skill.

You have confirmed both sides of the equation. Your agent can pull structured data from every connected system, but it cannot combine that data into a useful narrative on its own. Next, you will teach it exactly how.

Author Your Weekly Review Skill

Your agent can reach into GitHub, Gmail, and Calendar individually. But when you asked for a "weekly review" in the last step, it dumped everything without structure or narrative.

A skill fixes this. It is a Markdown file you drop into your Hermes skills directory that teaches your agent a precise procedure and output format. Once saved, the skill is live forever. No registration, no deployment.

In this step, get ready to:
  • Author a complete SKILL.md that teaches your agent a multi-system weekly review workflow.
  • Test the skill in a fresh session and see structured output from all three systems.
  • Verify the skill persists across sessions as a permanent capability.
Create the skill directory and write SKILL.md

Hermes discovers skills automatically from files in ~/.hermes/skills/. You organize skills into category subfolders.

  • Create the skill directory by running this command:
mkdir -p ~/.hermes/skills/productivity/weekly-review
  • Confirm the directory was created by running:
ls ~/.hermes/skills/productivity/

You should see weekly-review listed as a directory.

  • Open a new file in the skill directory by running:
nano ~/.hermes/skills/productivity/weekly-review/SKILL.md

Your skill file needs four sections: frontmatter that identifies the skill, a procedure that defines the workflow, an output format that specifies the structure, and pitfalls that handle edge cases. You will add each section below the previous one.

  • Start by pasting the YAML frontmatter and the When to Use section:
---
name: weekly-review
description: Generate a structured weekly review combining GitHub activity, Google Calendar meetings, and Gmail threads into a single narrative summary.
version: 1.0.0
metadata:
  hermes:
    tags: [productivity, review, github, gmail, calendar]
    category: productivity
---

# Weekly Review

## When to Use

Use this skill when the user asks for a weekly review, weekly summary, or wants to know what they accomplished in the past week. Also triggered by `/weekly-review`.

What does this section do?

The YAML frontmatter between the --- lines registers the skill with Hermes. The name field becomes the slash command (/weekly-review).

The tags and category help Hermes decide when this skill is relevant. The "When to Use" section tells the agent which user requests should activate this skill.

  • Below what you just pasted, add the Procedure section:

## Procedure

1. **Determine the date range.** Default to the last 7 days unless the user specifies otherwise. Use the current date and calculate 7 days back.

2. **Pull GitHub activity.** Use the GitHub MCP tools to:
   - List commits from the past 7 days across the user's active repositories
   - List pull requests opened, merged, or closed in the period
   - Note any issues created or closed

3. **Pull Calendar meetings.** Use `$GAPI calendar list` to fetch events from the past 7 days. Group by day.

4. **Pull relevant email threads.** Use `$GAPI gmail search` to find emails from the past 7 days. Focus on threads with replies (actual conversations, not newsletters). Limit to 10 most relevant.

5. **Synthesize the review.** Combine all data into the Output Format below. Do not just list raw data. Write brief narrative sentences that connect the dots. For example, if a PR was merged the same day as a meeting about that feature, note the connection.

What does the Procedure section do?

This is the heart of your skill. Each numbered step is an instruction your agent follows in order. It tells the agent exactly which tools to call ($GAPI calendar list, $GAPI gmail search, and the GitHub MCP tools) and what to do with the results.

Step 5 is what transforms raw data into a useful narrative. Without it, you would get the same unstructured dump you saw in Step 2.

  • Continue by adding the Output Format section below the Procedure:

## Output Format

```
# Weekly Review: [start date] - [end date]

## Shipped
- [PR/commit description]: [one-line impact note]
- ...

## Meetings
- [Day]: [meeting title] - [one-line takeaway or decision]
- ...

## Communication
- [Thread subject]: [one-line summary of outcome or action item]
- ...

## Next Week
- [Inferred action items based on open PRs, upcoming calendar events, or unresolved email threads]
```

What does the Output Format do?

This is a template your agent follows when structuring its response. Without it, the agent would choose its own format every time. The four sections (Shipped, Meetings, Communication, Next Week) ensure every review is consistent and scannable.

  • Finally, add the Pitfalls and Verification sections at the bottom:

## Pitfalls

- Timezone: Calendar events and commits use different timezone conventions. Always convert to the user's local timezone before comparing dates.
- Empty results: If any system returns no data for the period (e.g., no commits), note "No activity" in that section rather than omitting it.
- Large repos: If the user has many repos, ask which ones to include or default to repos with recent activity.
- Email noise: Filter out automated emails (GitHub notifications, calendar invites) from the Communication section. Focus on human-written threads.

## Verification

After generating the review, confirm with the user: "Here's your weekly review. Want me to adjust the date range, add more detail to any section, or save this to a file?"

What do Pitfalls and Verification do?

Pitfalls warn the agent about common failure modes before they happen. Timezone mismatches between GitHub and Calendar are the most common issue in multi-system workflows.

The Verification section tells the agent to confirm with you after generating the review, giving you a chance to adjust before the output is final.

  • Save the file by pressing Ctrl+O, then Enter, then Ctrl+X to exit nano.
  • Confirm Hermes discovers your skill by running:
hermes skills list | grep weekly-review

You should see weekly-review listed with your description. The skill is live. You dropped a file and Hermes found it automatically.

Don't see weekly-review in the list?

  • Check the file path is exactly ~/.hermes/skills/productivity/weekly-review/SKILL.md. A typo in any directory name prevents discovery.
  • Verify the YAML frontmatter starts with --- on the very first line of the file. No blank lines before it.
  • Make sure the name: field in your frontmatter reads weekly-review (lowercase, hyphenated).

Help me troubleshoot why my skill isn't showing up in hermes skills list.

✔️ Awesome, I've got everything!

Great. Double check you saved SKILL.md and that nano closed cleanly.

ⓧ I'd like to double check the full code

Your SKILL.md is over 30 lines, so scroll through it and confirm these sections appear in order:

  • YAML frontmatter (between --- markers) with name: weekly-review, version: 1.0.0, and the metadata block.
  • # Weekly Review heading followed by ## When to Use.
  • ## Procedure with 5 numbered steps (date range, GitHub, Calendar, Gmail, synthesize).
  • ## Output Format with the template block containing Shipped, Meetings, Communication, and Next Week.
  • ## Pitfalls with 4 bullet items (Timezone, Empty results, Large repos, Email noise).
  • ## Verification with the confirmation prompt.

You can reopen the file to check by running:

nano ~/.hermes/skills/productivity/weekly-review/SKILL.md
Test the skill in a fresh session

Your skill file is saved. Now you will see what it actually does when your agent runs it.

  • Return to the Hermes WebUI at http://localhost:8787.
  • Start a new session (or send /reset to clear the current one).

Before you run this, think back to Step 2. When you asked for a "weekly review" without a skill, the output was unstructured. What do you expect to be different now?

  • Send this message in the new session:
/weekly-review

Your agent loads the skill and executes the procedure. It pulls GitHub commits and PRs from the last 7 days, lists your calendar meetings, searches relevant email threads, and formats everything into the structure you specified.

What should I see?

The output should have clear section headings: Shipped, Meetings, Communication, and Next Week. Each section contains narrative sentences drawn from real data in your connected systems.

Compare this to the raw dump from Step 2. The difference is your skill at work. Same data, structured procedure, polished output.

Seeing generic output instead of the structured format?

  • Make sure you started a fresh session. Skills are loaded at session start. An old session will not pick up a newly created skill.
  • Check that the skill file has the correct name: weekly-review in its frontmatter. The slash command is derived from this name.
  • If the agent asks clarifying questions instead of running the procedure, your "When to Use" section may not match. Verify it mentions /weekly-review as a trigger.

Help me figure out why my weekly-review skill is not producing structured output.

Verify the skill persists across sessions

A skill is only useful if it survives restarts. You need to confirm this is not a one-time thing.

  • Close the Hermes WebUI browser tab entirely.
  • Reopen it at http://localhost:8787 and start a completely new session.

Do you think the skill will still be available in this brand new session?

  • In your terminal, verify the skill is permanently installed by running:
hermes skills list | grep weekly-review

You should see weekly-review listed with your description. The skill is permanently installed. No registration, no deployment. You dropped a file and it is live.

Why does this work without registration?

Hermes uses a progressive disclosure pattern. At session start, it runs skills_list() to load a compact index of all skills (about 3k tokens). When you invoke a skill, it calls skill_view(name) to load the full SKILL.md on demand.

This means any Markdown file with valid frontmatter in ~/.hermes/skills/ is automatically discoverable. You are now a skill author.

Your agent has a permanent new capability. Next up, you will schedule it to run autonomously every Friday and deliver the review to your phone.

Schedule Your Weekly Review as a Cron Job

Your weekly-review skill works. You tested it, saw the structured output, and confirmed it persists across sessions. Now the question is: should you have to remember to ask for it every Friday?

The answer is no. In this step, you'll schedule a cron job that fires your skill automatically every Friday at 5:00 PM. Your agent pulls fresh data from all three systems and delivers the formatted review straight to your phone via Hermex.

In this step, get ready to:
  • Create a cron job with your weekly-review skill attached.
  • Trigger the job manually and verify structured output.
  • Confirm delivery on your phone via Hermex.
Create the cron job with your skill attached

Hermes cron jobs are scheduled tasks that run in fresh sessions on a timer. The key feature here is skill attachment. When you attach a skill to a cron job, the agent loads your exact procedure before executing the prompt.

  • In the Hermes WebUI, send the following message to your agent to create the cron job:
Create a cron job called "Weekly Review" that runs every Friday at 5:00 PM. Attach the weekly-review skill. The prompt should be: "Run my weekly review for the past 7 days. Include GitHub activity, calendar meetings, and relevant email threads. Format the output using the skill's output format." Deliver to origin.

What does this message do?

Your agent translates this into a cronjob tool call with these parameters:

  • schedule="0 17 * * 5" means "at 5:00 PM every Friday" in cron syntax.
  • skill="weekly-review" tells the agent to load your SKILL.md before executing.
  • Deliver to origin means the result goes back to wherever the job was created. On a messaging platform like Hermex, that means your phone.
  • Confirm the job was created by sending this message:
List my cron jobs

You should see "Weekly Review" listed with schedule 0 17 * * 5 and skill attachment weekly-review.

Don't see the cron job listed?

  • Make sure you typed the skill name exactly as weekly-review. The agent matches this against your skill directory name.
  • Check that your agent confirmed job creation before you asked to list. If it asked a clarifying question instead, answer it and try again.

Why isn't my cron job appearing in the list?

Trigger the job and verify the output

You do not have to wait until Friday to see your cron job in action. Hermes lets you trigger any job immediately with the run action.

Before you trigger it, think about what you expect to see. Will the output be a raw data dump like before, or the structured format you defined in your skill?

  • Send this message to trigger the job immediately:
Run the Weekly Review cron job now

Watch the agent work. You will see it processing GitHub, Calendar, and Gmail commands in sequence as it follows your skill's procedure.

  • Wait for the job to complete. The formatted review appears in your current session.
  • Verify the output contains all four sections from your skill: Shipped, Meetings, Communication, and Next Week.

What just happened?

The agent used cronjob(action="run", ...) to trigger the job on the next scheduler tick. Because your skill was attached, the agent loaded your full SKILL.md procedure before executing the prompt. That is why the output matches your defined format instead of producing a generic dump.

Output missing sections or looking unstructured?

  • If a section says "No activity", that is expected. Your skill handles empty results gracefully.
  • If sections are missing entirely, confirm the skill attachment by running "List my cron jobs" and checking that weekly-review shows as the attached skill.
  • If you see errors about GitHub permissions, confirm your personal access token is still valid at https://github.com/settings/tokens.

My cron job ran but the output doesn't match my skill format. How do I fix this?

Verify delivery on your phone

The cron job delivers to origin, which means Hermex on your phone receives the same output. This is how the job will work autonomously every Friday.

  • Open Hermex on your phone.
  • You should see the formatted weekly review delivered in the session. The same structured output with Shipped, Meetings, Communication, and Next Week sections is now accessible from your phone.

How does autonomous execution work?

As long as hermes gateway is running, your cron job fires automatically at the scheduled time. Every Friday at 5:00 PM, the agent spins up a fresh session, loads your skill, executes the full procedure, and delivers the result. No manual trigger needed.

Your agent now has a permanent, autonomous workflow. Every Friday it reviews your week across GitHub, Calendar, and Gmail, then delivers a polished summary to your phone. Next up, you'll push this even further with cron job chaining in the Secret Mission.

Secret mission

Chain a Highlights Email Draft

Your weekly review is great for you. But what about your manager or team? In this mission, you'll chain a second cron job that takes your review output, extracts the highlights, and drafts a professional email in Gmail. Every Friday, fully automated.

Clean Up Your Resources

Clean Up Your Resources

This project runs entirely locally with no ongoing costs. Decide whether to keep your resources running, pause them to come back later, or delete them entirely.

Resources you used:

  • GitHub Personal Access Token (stored in ~/.hermes/config.yaml).
  • GitHub MCP server configuration (local subprocess defined in ~/.hermes/config.yaml).
  • Custom skill at ~/.hermes/skills/productivity/weekly-review/SKILL.md.
  • Two cron jobs stored in ~/.hermes/cron/jobs.json (Weekly Review and Highlights Email).

Keep everything running

No action needed. Choose this if you want your Weekly Review to fire every Friday at 5:00 PM and your Highlights Email at 5:30 PM automatically.

  • Your cron jobs run as long as hermes gateway is active. There is no ongoing cost.
  • Your skill file and MCP configuration persist in ~/.hermes/ and are available in every new session.
  • Your GitHub Personal Access Token remains active until you revoke it manually.

Pause - I'll come back to this later

Shut down the scheduler so cron jobs stop firing, but keep all configuration intact for when you return.

  • Stop hermes gateway by pressing Ctrl+C in the terminal where it is running.
  • Your cron jobs remain configured in ~/.hermes/cron/jobs.json but will not fire until you restart the gateway.
  • All skills and MCP configuration persist. When you are ready to resume, run hermes gateway again.

Delete - I don't want to use this again

Remove all project resources completely. This revokes access and deletes local files.

  • Revoke your GitHub Personal Access Token by visiting https://github.com/settings/tokens. Find the token named Hermes Agent and click Delete.
  • Remove the GitHub MCP server configuration from your Hermes config by running:
nano ~/.hermes/config.yaml

Delete the entire github: block under mcp_servers, then save and exit.

  • Delete the weekly-review skill by running:
rm -rf ~/.hermes/skills/productivity/weekly-review
  • Remove the cron jobs by opening the Hermes WebUI and sending this message to your agent:
Remove the Weekly Review and Highlights Email cron jobs
  • Confirm removal by asking your agent to list cron jobs. You should see an empty list.

That's a Wrap!

That's a Wrap!

Nice work! You've gone from Hermes user to Hermes skill author. Your agent now has a permanent capability you designed from scratch, one that coordinates across GitHub, Gmail, and Calendar and runs autonomously every Friday.

You've learned how to:

  • Connected GitHub to your Hermes Agent via MCP, giving it live access to your repos, commits, issues, and pull requests through natural language.
  • Authored a custom weekly-review skill from scratch: a SKILL.md file that teaches your agent a multi-system workflow combining GitHub, Gmail, and Calendar into a formatted weekly narrative.
  • Scheduled autonomous execution with a Friday cron job that runs your skill unattended and delivers the review to your phone.
  • (Secret Mission) Chained a second cron job using context_from that transforms your review into a professional highlights email draft, demonstrating the most advanced scheduling pattern in Hermes.

Ready to quiz yourself?