Turning Discord Into My Personal AI Operating System with Hermes

+-------------------+       +-------------------+       +--------------------+
|                   |       |                   |       | - Local CLI Tools  |
|  Discord UI       | <---> |  Hermes Agent     | <---> | - Webhooks & APIs  |
|  (Channels/Chats) |       |  (Memory/Skills)  |       | - Cron Jobs        |
|                   |       |                   |       | - Notion / DBs     |
+-------------------+       +-------------------+       +--------------------+

For the last couple of years, the tech industry has been trying to convince us that the chat box is the ultimate interface for artificial intelligence. We treat LLMs like highly educated, highly volatile search engines: typing questions into a void, getting a text response, and then manually copying and pasting that output into the places where we actually do our work. But as a software developer, I wanted something more. I needed a system that wasn’t just a passive oracle, but an active, persistent connective tissue operating across my daily workflows.

Recently, I crossed that bridge by running Hermes Agent connected directly to Discord. Discord has officially evolved from a place to hang out into the front door of my “second brain”. It feels less like a chat app now and significantly more like a command center for personal automations.

Let’s crack open the hood and look at how this transition from chatbot to agent actually works, what the real-world workflows look like, and why this architectural shift feels so fundamentally different.

What Are We Actually Building?

Before we get into the code and the configurations, we need to define the tool. Hermes Agent is an open-source AI agent framework developed by Nous Research. Unlike standard web-based AI interfaces, Hermes isn’t confined to a single browser tab. It is designed to run across multiple surfaces. You can hook it up to a CLI, a desktop dashboard, your IDE context, or, in my case, messaging platforms like Discord.

What makes it an “agent” rather than a bot is its capability stack: it supports native tool calling, persistent memory, reusable operational procedures (called skills), scheduled cron jobs, incoming webhooks, local system integrations, and the ability to seamlessly swap between multiple LLM providers.

Why Discord?

You might wonder why I chose Discord as the interface rather than building a custom web UI or just living in the terminal. The answer is simple: Discord maps perfectly to how human brains organize context. Channels and threads provide a natural, isolated structure for different workflows and topics. Plus, I’m already there.

There is one critical limitation you need to understand about this setup: Hermes does not magically gain full Discord administrator privileges or deep search access to the entire server history. It cannot arbitrarily scrape your old conversations. It can only respond to the messages it specifically receives and deliver its outputs to the destinations you configure. The real power isn’t in Discord itself; it’s in the tools and local scripts sitting behind the agent.

Concrete Workflows: The Agent in Action

Theory is great, but let’s look at what this actually does on a Tuesday afternoon. Here are five concrete workflows I rely on.

1. The Frictionless Article Ingestion Pipeline

I consume a massive amount of technology news every day, specifically tracking developments in AI, TypeScript, and Golang. I used to keep dozens of browser tabs open as a makeshift reading list. Now, I just drop an article URL into a dedicated Discord channel.

When Hermes sees that URL, it triggers two local tools simultaneously. First, it fires up Meridiano. To give you some context, Meridiano isn’t just a simple read-it-later script: it’s my custom personal news and intelligence briefing platform. It ingests RSS feeds, scraped URLs, and YouTube transcripts. Then, it uses AI to summarize the article, assign an editorial “Impact Rating,” generate embeddings, and cluster related topics together (using K-means via ml-kmeans). It takes all of this and synthesizes a “Standard Briefing” grouped by Feed Profile (which covers categories that I want to follow closely like technology, politics, health, science, and brasil). It can even generate text-to-speech audio of these summaries using OpenAI TTS or Groq’s Orpheus model, storing them in S3 with presigned playback URLs. (It also handles a separate, ad hoc YouTube transcription pipeline for registered channels, but those are kept strictly isolated from the main briefings).

So, when Hermes receives a new article link, it runs:

meridiano articles "<url>" --feed-profile technology

(If I just drop the link without specifying a profile, Hermes relies on its instructions to default to the technology profile automatically.)

Simultaneously, Hermes saves the link to my local bookmarking service, Karakeep:

karakeep --server-addr "$KARAKEEP_SERVER_ADDR" bookmarks add --link "<url>"

One quick Discord message instantly turns into both deep article processing and structured bookmarking.

2. The 7 AM Signal-in-the-Noise Digest

Social media is a firehose. I want the signal, but I don’t want to do the scrolling. To fix this, I set up Hermes to run a daily scheduled digest: a cron job that executes exactly around 7am Brazil time every morning.

This job collects original posts and quote posts from a tightly curated list of tech and AI accounts. It strictly excludes replies and reposts to cut out the noise. Hermes then summarizes each account’s output, links to the most important posts, and, most impressively, highlights overarching topics that are appearing across multiple accounts. It turns a noisy timeline into a highly compact, readable morning briefing waiting for me in Discord when I wake up.

3. The Notion Watch List (And Learning from Mistakes)

Friction is the enemy of a good second brain. If someone recommends a movie, I don’t want to open Notion, find the right database, create a new row, and tag it. Instead, I just send Hermes a shorthand message in Discord:

movie interstellar max

Hermes intercepts this, interprets the raw thought, and formats it into a Notion watch-list item:

[movie] Interstellar [Max]

It then handles the API calls to add it to the correct Notion database with the proper tags and date metadata.

Here is the crucial part that separates an agent from a dumb script: early on, Hermes mistakenly logged a movie to the wrong Notion database. I corrected it directly in the Discord thread. Hermes didn’t just apologize; it explicitly saved the corrected rule to its memory for the future, permanently fixing the behavior without me having to touch a config file.

4. The Samsung Health Webhook (A Diagnostic Story)

Not every automation works perfectly out of the box, and that’s exactly where an agent proves its worth. I wanted Hermes to summarize my workout data directly from Samsung Health into Discord.

The realistic architecture we mapped out was complex: Samsung Health → Android Health Connect → custom Android exporter app → Hermes webhook → Discord summary

Hermes actually helped me write the code, build the integration, and troubleshoot the pipeline. The webhook routing from my phone to Hermes worked flawlessly. The real blocker? After hours of testing, Hermes helped me diagnose that Samsung Health simply wasn’t writing the workout records into Health Connect yet.

A traditional automation platform would just throw a generic 500 error. Hermes, acting as a diagnostic partner, helped map the system boundary and figure out exactly why the chain was breaking. It’s a perfect example of an agent helping you understand when an automation is blocked by external limits rather than pretending it succeeded.

5. Backing Up the Brain

As Hermes started handling more of my daily infrastructure, I had a terrifying thought: What happens if this machine dies? Are the agent’s memories, learned skills, and personality files actually backed up?

I asked Hermes directly. It checked its own state, and then actively helped me create a safe, automated daily snapshot that pushes its brain into a git-backed personal wiki. Because it understands its own architecture, it knew exactly how to exclude runtime state and sensitive secrets from the commit. The snapshot safely ignores .env files, auth tokens, logs, caches, databases, and session dumps.

The Enabling Layer: Memory and Skills

Why does this feel so different from ChatGPT or Claude? It comes down to two architectural concepts: Memory and Skills.

Hermes doesn’t just replace my existing tools like Notion, Karakeep, Meridiano, or my local file system. Instead, it acts as the intelligent glue between them. Memory allows the agent to store stable facts and user preferences permanently. Skills allow it to store and reuse complex procedures. When you combine these with its ability to run local CLIs, hit webhooks, and verify the outcomes of its own actions, you stop talking to a bot and start managing a system. Corrections compound. The system gets sharper the more you use it.

The Rough Edges

I won’t pretend this is a flawless, frictionless utopia. Building personal AI infrastructure is still very much a workshop project.

Integrations require real setup time. Handling secrets and API keys across different tools requires careful management so you don’t accidentally leak tokens. Platform APIs have strict rate limits that you will inevitably hit. Most importantly, you cannot blindly trust the agent; you have to build in verification steps to ensure its actions actually matched your intent.

Conclusion

The transition from a passive chatbot to an active, Discord-based agent has completely changed how I interact with my personal data. The real “aha” moment isn’t any single massive feature. It’s the simple, reliable fact that I can send a casual message in Discord and trigger real, verifiable workflows across my local machine, scheduled jobs, web services, and knowledge systems.

The value of a true second brain doesn’t come from one massive architectural overhaul. It compounds quietly, day by day, as these small, reliable automations accumulate.

Down the Rabbit Hole