r/hermesagent
•
u/Chasmchas
•
Sep 20 '26
r/hermesagent
•
u/Jonathan_Rivera
•
Apr 23 '26
Workshop How I use Obsidian as the long-term memory backbone for my AI assistant
I have been running a personal AI assistant setup for a little over a month now. I started with apple notes but found that apple script were limited and would not let Hermes add and delete without a fuss. This project started originally as a second brain setup but then I kept seeing complaints about token usage. At the time I was on open router, even though I run on local now I still wanted to eliminate the bloat. I also wanted a space that Hermes could log everytime we fixed something so I didn't have to start from scratch every time an update wrote over our patch.
My answer has been Obsidian — not as a fancy AI notebook, but as a structured knowledge base the assistant can read from and write to autonomously.
Here's how it actually works under the hood. (Yes Hermes helped me write this because I committed to writing this post a few hours ago, buckle up)
The Three-Tier Memory System
The core idea is simple: not all information needs the same treatment. Some facts change every day. Some are stable for months. Some are just event logs. I split memory into three tiers:
Tier 1 — Hot Memory (per-session, ~9K characters) This is injected into every conversation turn automatically. It covers things like communication preferences, active projects, recent corrections, and procedural quirks. Think of it as the assistant's working memory — fast to access, but limited in size. When it gets full, something has to move.
Tier 2 — Vault Living Files (stable reference, on-demand) When hot memory hits about 67% capacity, I scan for entries that are stable enough to promote. Things like environment configs, operational context, and known failure patterns get written to markdown files in the Obsidian vault. The assistant reads these on-demand when deeper context is needed. This keeps the per-turn context window lean while still having access to months of accumulated knowledge.
Tier 3 — Daily Notes (searchable timeline) Every day, a dated note is created with tasks, schedule, and a log section. Events get recorded throughout the day. This creates a searchable history of decisions and actions. The assistant can search past daily notes to recall what happened on a specific date or track how a project evolved over time.
The Morning Briefing Pipeline
This is the workflow that runs every weekday morning and it's the one that shows the system best in action.
6:50 AM — Data Collection A cron job fires and does three things:
Fetches tasks from Todoist via API, categorizing them by project (work, personal, side business)
Fetches calendar events from Google Calendar, filtering out noise like sleep tracking entries
Creates or updates the daily note at
Daily/YYYY-MM-DD.mdin the Obsidian vault
The daily note follows a strict format:
Tasks section with checkboxes, priority tags, and overdue tracking
Schedule section with time-blocked events
Empty log section for recording things during the day
Wins section for end-of-day wrap-up
Context section with backlinks to people, decisions, and files
7:00 AM — Delivery A second cron job reads the cached data and delivers a formatted briefing directly to my Telegram. It's clean — no checkboxes, just bullets organized by category with an overdue count. I wake up, check my phone, and know exactly what the day looks like.
The Finance Briefing
Every weekday at 9 AM, another cron job runs:
Navigates to Yahoo Finance for each tracked ticker
Extracts current price, daily change, and recent headlines
Classifies each headline's sentiment (bullish, neutral, bearish)
Delivers a summary table to Telegram
The output looks like a mini market report. If there's nothing new for a ticker, it says so. The whole thing runs autonomously — no prompting needed.
How Information Moves Through the System
Here's the data flow in simple terms:
External APIs (Calendar, Todoist, Stocks, Email, Weather) feed into the AI assistant. The assistant processes this data through scheduled cron jobs and interactive skills. The results land in two places:
Hot memory for immediate context (preferences, corrections, active state)
Obsidian vault for persistent storage (daily notes, operational docs, stable reference files)
The vault also feeds back — the assistant reads vault files on-demand when it needs deeper context that isn't in hot memory. It's a two-way street.
Why Obsidian Specifically
A few reasons this works well with Obsidian specifically:
Plain text markdown — The AI can read and write Obsidian notes without any special plugins or APIs. It's just files on disk.
Backlinks and graph view — When the assistant links to a person, decision, or file in a daily note, Obsidian's native linking creates a visual graph of connections over time. You can actually see how topics relate.
Searchable history — Every daily note is a timestamped record. Need to know what happened last Tuesday? Search the vault. The AI can do the same thing.
Works without the AI — The vault is still a fully functional PKM system even if the assistant goes offline. No vendor lock-in.
Vault Structure
Here's what the folder hierarchy looks like:
Vault/
├── Daily/ # YYYY-MM-DD.md daily notes
├── System/
│ └── Assistant/
│ ├── context.md # Operations overview
│ ├── preferences.md # Communication style
│ └── environment.md # Hardware, services, known issues
├── Work/
│ ├── Business-A/ # Workplace safety operations
│ └── Business-B/ # Cleaning services operations
├── Personal/
│ ├── Finance/ # Stock tracking, budgets
│ └── Health/ # Weight, sleep, Steps protocol
├── People/ # Contacts map of content
└── Inbox/ # Unclassified incomingThe key discipline is the filing rules: operational events go to the daily log, system issues go to a separate troubleshooting log, learned corrections go to hot memory (or vault if stable), and recurring workflows become skill files.
What This Enables
Persistent context across sessions — The assistant remembers corrections, preferences, and project state without me repeating myself
Automated daily standups — Morning briefing, finance report, and check-in reminders all run on schedule
Searchable decision history — Every daily note is a timestamped record of what happened, what was decided, and what files were involved
Separation of concerns — Work and personal contexts are clearly separated in both the vault structure and the briefing output
Getting Started (High Level)
Here is the template you can copy paste to your hermes.
Obsidian + AI Assistant — Starter Template
Copy and paste the instructions below into your AI assistant (Hermes, Claude, Cursor, etc.) to set up an Obsidian vault that works as persistent long-term memory.
Part 1 — Tell Your AI Assistant This
Paste the following block into your AI assistant as system instructions or a persistent prompt. Adjust the vault path to match where you actually create the vault.
OBSIDIAN VAULT INTEGRATION
You have access to an Obsidian vault that serves as persistent long-term memory.
The vault root is: /PATH/TO/YOUR/VAULT/
VAULT STRUCTURE:
Vault/
├── Daily/ # YYYY-MM-DD.md daily notes — append-only
├── System/
│ └── Assistant/
│ ├── context.md # Operations, health, family overview
│ ├── preferences.md # Communication style, delivery rules
│ └── environment.md # Hardware, services, known issues
├── Work/
│ └── Business/ # Work documents, reports, logs
├── Personal/
│ └── Projects/ # Side projects, personal tracking
├── People/ # Contacts, relationships, MOC
└── Inbox/ # Unclassified incoming — file these later
RULES FOR VAULT ACCESS:
1. DAILY NOTES
- Create Daily/YYYY-MM-DD.md each day if it does not exist
- Use frontmatter: ---\ndate: YYYY-MM-DD\ntype: daily\ntags: [daily]\n---
- Sections in order: ## Tasks, ## Schedule, ## Log, ## Wins, ## Context
- Tasks use checkboxes: - [ ] Task Description (p2), (p3), (p4)
- Log entries: - HH:MM AM/PM — what happened
- Wins: completed items with checkmark: ✅ Task Description
- Context section: backlinks to People, Decisions, Files
- APPEND ONLY — never delete content from daily notes
2. MEMORY PIPELINE (Three Tiers)
- Tier 1 — Hot Memory: Your per-session memory (MEMORY.md or equivalent).
Injected every turn. Keep it under 6000 characters. Covers active projects,
recent corrections, communication preferences, procedural quirks.
- Tier 2 — Vault Living Files: When hot memory hits ~67% capacity, promote
stable entries to System/Assistant/ files (context.md, preferences.md,
environment.md). Read these on-demand when deeper context is needed.
- Tier 3 — Daily Notes: Searchable timeline. Every event logged during the day
creates a permanent timestamped record. Search past daily notes to recall
what happened on a specific date.
3. CONTENT ROUTING
When the user says "log it" or "save it", route by type:
- Operational events (meetings, calls, decisions) → Daily/YYYY-MM-DD.md ## Log
- System issues, technical fixes → System/Assistant/logs/issues-fixes-log.md
- Learned corrections, preferences → Hot memory (or vault if stable)
- Recurring workflows → Save as a reusable skill/procedure file
- Unknown incoming → Inbox/ until classified
4. VAULT HYGIENE
- Always use Obsidian wiki-links: [[People/Name]], [[Daily/2026-04-23]]
- Build the link graph — every person, decision, and file mentioned in daily
notes should be linked so the vault graph view shows real connections
- Notice orphaned notes unprompted — if a note has no incoming links, flag it
- Never delete vault content without explicit user confirmation
- Use absolute paths when referencing vault files
5. PERSONA FILE SETUP
Tell the user to create the following three files in System/Assistant/:
System/Assistant/context.md — Current life situation, active things to track.
Include: operations overview, health goals, family, work dependencies,
location/timezone, admin tendencies.
System/Assistant/preferences.md — How the user likes things done.
Include: communication style, agenda ordering, delivery preferences,
session style, task management conventions.
System/Assistant/environment.md — Hardware, tools, known issues.
Include: hardware specs, services/ports, key file paths,
known failure patterns, troubleshooting steps.
6. HOT MEMORY FILES
The AI assistant uses two memory files that are injected into every session:
MEMORY.md — Your personal notes (procedural knowledge, environment facts,
tool quirks, lessons learned). Format each entry with a § separator.
Keep entries compact and factual. Delete entries that are no longer relevant.
USER.md — Who the user is (name, role, preferences, timezone, family,
vault lookup map). This helps the assistant personalize responses.
Both files live in the AI's memory directory (e.g., ~/.hermes/memories/)
and are automatically loaded at the start of each session.Part 2 — Create the Vault Folder Structure
Run this in your terminal to scaffold the vault:
VAULT_PATH="/PATH/TO/YOUR/VAULT"
mkdir -p "$VAULT_PATH"/{Daily,System/Assistant/logs,Work/Business,Personal/Projects,People,Inbox}
# Create the three core assistant files
cat > "$VAULT_PATH/System/Assistant/context.md" << 'EOF'
# Assistant — Context
Current life situation, health protocols, and active things to track.
Read when context matters for decisions or advice.
---
## Operations
- Describe your main work or business here
- Note any secondary projects or side operations
## Health
- Goals and baselines
- Any recurring protocols or reminders
## Family
- Key people and relationships
- Link to People/ folder for details
## Work Dependencies
- Who you wait on for approvals or sign-offs
- Blockers and their schedules
## Location & Timezone
- Home address (optional)
- Timezone
- Weather location
---
*Last updated: YYYY-MM-DD*
EOF
cat > "$VAULT_PATH/System/Assistant/preferences.md" << 'EOF'
# Assistant — Preferences
How you like things done. Read this when unsure about tone, format, or approach.
---
## Communication
- Concise, direct. Dry wit welcome. Never sycophantic.
- One clear sentence beats three hedged ones.
- When something is urgent, say so plainly.
## Operations Separation
- Keep work and personal clearly separated
- Never mix contexts without explicit labeling
## Agenda & Briefings
- Priority ordering: Due today > Active/P1 > Bills > Upcoming
- Morning brief: always read from actual daily note. Never show template placeholders.
## Task Management
- Every task completion paired with a log entry in daily note
- EOD wrap-ups sourced from daily note log
## Delivery Preferences
- Where should scheduled summaries go? (email, messaging app, etc.)
## Session Style
- Continuous same-session conversations or fresh starts each day?
---
*Last updated: YYYY-MM-DD*
EOF
cat > "$VAULT_PATH/System/Assistant/environment.md" << 'EOF'
# Assistant — Environment & Technical Setup
Hardware, tools, quirks, and gotchas. Read when troubleshooting or configuring.
---
## Hardware
- Primary machine and specs
- Any secondary devices or servers
## Services
- Key services, ports, and endpoints
- API configurations
## Key Paths
Resource | Path
----------|------
Vault | /PATH/TO/YOUR/VAULT/
Daily notes | /PATH/TO/YOUR/VAULT/Daily/YYYY-MM-DD.md
## Known Issues & Patterns
- Document any recurring problems and their fixes here
---
*Last updated: YYYY-MM-DD*
EOF
# Create the issues log
cat > "$VAULT_PATH/System/Assistant/logs/issues-fixes-log.md" << 'EOF'
# Issues & Fixes Log
Append-only record of system issues, technical failures, and their resolutions.
Format: Symptom → Root Cause → Fix → Status
---
*No entries yet.*
EOF
# Create People MOC
cat > "$VAULT_PATH/People/MOC.md" << 'EOF'
# People — Map of Content
Contacts and relationships. Each person gets their own note in this folder.
---
## Family
- [[People/Partner]] — spouse/partner
- [[People/Child]] — children
## Work
- [[People/Colleague]] — key colleagues
## Personal
- [[People/Friend]] — friends and acquaintances
---
*Last updated: YYYY-MM-DD*
EOF
echo "Vault scaffolded at $VAULT_PATH"Part 3 — Create Your First Daily Note
After the vault is set up, ask your AI assistant to create today's daily note. It should follow this format:
---
date: 2026-04-23
type: daily
tags: [daily]
---
## Tasks — 2026-04-23
### Work
- [ ] Task description (p2)
- [ ] Another task (p3)
### Personal
- [ ] Personal task (p4)
### Overdue
- [ ] Overdue task (since Apr 15)
### Waiting / Blocked
None
## Schedule — 2026-04-23
- 09:00 AM — Morning meeting
- 01:00 PM — Lunch with colleague
## Log
- 08:00 AM — Started daily note
## Wins — 2026-04-23
✅ Completed first task
## Context
- People: [[People/Colleague]]
- Decisions: None
- Files: NonePart 4 — Set Up the Memory Files
Your AI assistant needs two memory files that get injected into every session. The exact location depends on your AI platform, but the format is universal.
MEMORY.md (Hot Memory — Your Assistant's Notes)
# MEMORY.md — Assistant's Personal Notes
Accumulated procedural knowledge, environment facts, tool quirks, lessons learned.
Each entry separated by §. Keep compact. Delete stale entries.
§
ENTRY-NAME: Brief description of a fact, quirk, or lesson learned.
§
ANOTHER-ENTRY: Another fact or correction.
---
*Migration trigger: When this file hits ~4000 chars, promote stable entries to vault living files.*USER.md (User Profile — Who You Are)
# USER.md — User Profile
NAME: Your Name
TIMEZONE: Your Timezone (e.g., Eastern UTC-4)
WEATHER_LOCATION: Your City, State
FAMILY: Partner name, children, key relationships
VAULT LOOKUP MAP:
System/Assistant/context.md → operations, health, family overview
System/Assistant/preferences.md → communication style, delivery rules
System/Assistant/environment.md → hardware, services, known issues
Memory pipeline: MEMORY.md holds hot procedural knowledge.
Vault living files hold stable reference material.
Daily notes at /PATH/TO/YOUR/VAULT/Daily/YYYY-MM-DD.md
---
§
PREFERENCE: A specific preference or correction the assistant should remember.
§
ANOTHER-PREFERENCE: Another user-specific detail.Part 5 — How It All Works Together
[External Sources] --> [AI Assistant] --> [Hot Memory / Vault]
| | |
Calendar Your Tools MEMORY.md (hot)
Email (API, CLI) context.md
Tasks (browser, etc.) preferences.md
Weather environment.md
| | |
+-----> [Cron Jobs] -----> [Daily Notes] ----+The flow:
External data comes in through tools and APIs
The assistant processes it and decides where it belongs
Hot memory gets immediate context (preferences, corrections, active state)
Vault files get persistent storage (daily notes, operational docs, stable reference)
Vault feeds back — the assistant reads vault files on-demand when it needs deeper context
Why this works:
Plain text markdown means the AI reads and writes without special plugins
Backlinks create a visual graph of connections over time
Every daily note is a timestamped record — searchable by you and the AI
The vault is still fully functional even without the AI — no vendor lock-in
Three-tier memory keeps context windows lean while preserving accumulated knowledge
Part 6 — Maintenance
Weekly:
Check for orphaned notes in your vault (notes with no incoming links)
Review MEMORY.md — delete entries that are no longer relevant
If MEMORY.md exceeds 4000 characters, promote stable entries to vault files
Monthly:
Audit vault structure — are files in the right folders?
Check System/Assistant/ files for outdated information
Review Issues & Fixes Log for recurring patterns worth documenting as skills
When something breaks:
Log the issue in System/Assistant/logs/issues-fixes-log.md
If the fix is a recurring workflow, save it as a skill/procedure file
Update environment.md if it reveals a new known issue pattern
This template is a personal configuration, not a product. Adapt it to your needs.
r/hermesagent
•
u/uzairansar
•
Jul 02 '26
NEWS - Releases, Announcements, Updates Hermex is now opensource!
I was procrastinating on this for a while, but enough of you kept asking, so I finally got to it.
Just a little gift before we head out for the 4th of July weekend
Let me know what y'all think, and let's make Hermex the best app for our Hermes agents!
r/hermesagent • u/0xdippo • 10d ago
Hosting & Hardware My old Echo Dot run Hermes now, instead of Alexa.
I built a Home Assistant integration that connects it to a Hermes profile, with its memory and tools.
The shorting step is simple if you are even remotely comfortable opening up electronics.
Code, setup skill and the hardware recovery notes are public.
r/hermesagent
•
u/normVectorsNotHate
•
Oct 04 '26
MEMORY & Context — Providers, context window, forgetting issues I copied Muse's memory setup for my own Hermes agent and experienced significant improvement in results
I downloaded Muse just to experiment with it, even though I am a long time user of Hermes.
I use Hermes for general life management. I have ADHD and use it to manage my calendar and todo list and act as a productivity coach. I have Hermes set up to do weekly and monthly reflections on what patterns it sees, and how it can improve itself as a coach and how it can coach me to improve.
Just for fun, I had Hermes export all it's jobs and skills and then uploaded them to Muse. I was surprised that I was getting significantly better results with Muse. It seemed to be better at noticing useful patterns that I and Hermes had missed.
I dove into why this is the case and discovered it's probably due to how Muse manages memory. It creates daily md file logs, creates derived memory stores, and has a nightly dream functionality to synthesize all the information.
I had my Hermes do the same. And very quickly I noticed a step up in quality. Previously, the weekly reflections tended to be a recap of the todo items I did and calendar events even though I had put in the prompt to look for trends. After the change, I noticed it was really able to take a step up the abstraction ladder and be more holistic in it's analysis
I would encourage everyone to do the same. The 3 pieces you want:
daily memory md files
derived memory stores about the concepts important to you
nightly dreaming
Here's a more detailed breakdown of how Muse's memory is setup: https://mouse.dev/blog/muse-runtime-export/
r/hermesagent
•
u/kanzie
•
Oct 08 '26
Showcase I gave my Hermes setup a face
I wanted to test out the graphics capabilities in Opus5.5 and at the same time get a better view of everything that was going inside my server and specially with my Hermes agent setup that has grown a lot over the last few months.
So I set out with a small diorama which I populated with primitives, wired up to my different containers and services. Each building has a link to something running on my server. Every AI-member in my crew became a little animal I animated and all the agents that are spawned for coding, research, deployments etc. became little robots that self-detonate when their task is completed.
This left me with many animals just standing around when they weren't busy, so next I gave them personalities and hooked them up to my local LLM to generate dialogue and events which progress over time. They also got a collection of hobbies to fill their days with like Boule, Snowboarding or fishing. I can plant rumors and whisper in their ears and see it cascade and escalate.
I got my network wired up in the village too, with each wire showing what is going on there, a day-night-cycle, fireworks when a full test suite passes and chimneys visualizing current load.
For a bit more details on the build I wrote a blog post (the old-school way) and I also put a live demo on my website. for others to explore the village. It's running on obfuscated data and stacks a few of the events so not all things are real-time there, for privacy and entertainment purposes.
r/hermesagent
•
u/riceinmybelly
•
Jun 18 '26
Discussion - Workflows, habits, setup, best practices My Hermes setup, roast me
I've been running Hermes on an Apple Silicon Mac with a lot of RAM and thought I'd write up how it's structured, since the setup has grown into something fairly involved and there are some non-obvious pieces worth documenting for anyone trying to do the same.
What it's doing
The project is a job-site management app: Next.js frontend, NestJS API, postgres, redis, pgbouncer, nginx with brotli. I'm building it solo and Hermes handles the bulk of the actual implementation. It files its own tasks, writes the code, runs QA, deploys, and keeps its own documentation current. I mostly review things over Telegram.
Filesystem layout
Everything lives under ~/Hermes. Here's what actually gets mounted where:
~/Hermes/
hermes-config/ → /opt/data (hermes home dir)
hermes-profiles/ → /opt/data/.hermes (HERMES_HOME runtime data)
hermes-profiles/profiles/ → /opt/data/profiles (second mount — see symlinks below)
patches/ → individual files at /opt/hermes/** (see patches section)
workspace/myapp/ → /workspace/myapp (app source)
obsidian-vault/ → /workspace/obsidian (knowledge vault)
claude-auth/ → /opt/data/.claude (claude code auth)
qwen-config/ → /opt/data/.qwen
pi-config/ → /root/.npm-global (pi CLI install, persists across restarts)
pi-config/ → /workspace/pi-config (same dir, second mount)
bin/bw-linux-arm64 → /usr/local/bin/bw:ro (bitwarden CLI)
hermes-profiles/ holds all runtime state: kanban.db, active session files, cron state, logs, the dispatcher hook, and all profile configs. hermes-config/ holds the top-level config.yaml and auth state.
Docker layout
Hermes runs in Docker alongside SearXNG (web search, Google enabled, port 8888), Hindsight (semantic memory backed by pgvector, port 8889), Bitwarden Lite (secrets, port 8310), and hermes-pi.
hermes-pi is a node:20-slim container running @mariozechner/pi-coding-agent, a CLI that wraps multiple cloud inference providers. On startup it runs npm install -g @mariozechner/pi-coding-agent and then sleeps with tail -f /dev/null. The pi-config/ volume is mounted as /root/.npm-global so the install survives container restarts. All cloud API keys live here as environment variables: ZAI_API_KEY, OPENCODE_GO_API_KEY, etc. ANTHROPIC_API_KEY is explicitly empty so pi doesn't try to route through Claude. PI_OFFLINE=1 prevents auto-updates.
When Hermes needs cloud inference it calls hermes-bridge.py's /pi endpoint, which does:
docker exec -w /workspace hermes-pi /root/.npm-global/bin/pi --print --provider <name> --model <name> <prompt>
The bridge walks the provider list in order and moves on if it gets a non-zero exit or a rate limit marker in the output.
The app stack runs in its own separate docker-compose. Hermes has the Docker socket mounted (it needs it for container inspection and some tooling), but all deployment operations go through hermes-bridge.py on the macOS host rather than raw docker calls. The bridge exposes HTTP endpoints for build, deploy, git pull, service restart, log tailing, and dev stack management. It lives on the host rather than in Docker because git pull needs real localhost networking. It runs under launchd with KeepAlive.
Profiles
Four active profiles: local-admin, coder, planner, and qa-tester. There's also a repository profile that's just a shared skill directory.
The skills sharing setup is worth explaining. Each profile's skills/ directory has 40-50 symlinks pointing to /opt/data/profiles/repository/skills/<skill-name>. Those symlinks use the container path, not the host path. The problem is that HERMES_HOME=/opt/data/.hermes, so profiles live at /opt/data/.hermes/profiles — but the symlinks hardcode /opt/data/profiles. To resolve this, hermes-profiles/profiles/ gets bind-mounted twice: once as /opt/data/.hermes/profiles (through the .hermes mount) and once directly as /opt/data/profiles. Without that second mount every shared skill symlink breaks.
local-admin is the orchestrator. It handles Telegram, runs crons, and dispatches work to the other profiles. For its own work it uses Nous's free inference API (nemotron-3-ultra). The built-in dispatcher is disabled (max_spawn: 0) and a custom asyncio hook at profiles/local-admin/hooks/per-profile-dispatcher/handler.py runs on a 60-second tick instead. Hermes supports dropping a handler.py into a named subdirectory of hooks/ and it gets called each cycle — that's the built-in hook system.
The hook promotes tasks from todo to ready when their dependencies are resolved, reaps stalled workers (heartbeat stale at 15 minutes, startup timeout at 60 minutes, max runtime 4 hours), dispatches one task per profile that doesn't have an active worker, and diffs state on each tick so Telegram only gets a message when something actually changed. Spawn cooldowns: 10 minutes normally, 2 minutes if the last worker died within 2 minutes of starting (fast-retry), 30 minutes after 3+ consecutive failures.
coder is where most work happens. Provider chain in config.yaml:
model:
provider: zai
default: glm-5.1
fallback_providers:
- provider: opencode
model: deepseek-v4-pro
- provider: nous
model: stepfun/step-3.7-flash:free
- provider: lmstudio
model: qwen3.6-35b-a3b-mtp
base_url: http://host.docker.internal:1234/v1
Of course these models change a lot :)
LM Studio runs on the host at port 1234. From inside the container it's host.docker.internal:1234. It's the last fallback for when cloud is rate-limited or the task needs long uninterrupted tool call sequences where KV cache continuity matters.
planner does research and task filing, goes online via SearXNG, and writes daily ops notes to the vault. qa-tester handles E2E browser testing and API verification with Playwright.
Skills whitelist
By default every profile loads every skill, which bloats the system prompt badly. The patched skill_utils.py adds whitelist support:
skills:
include:
- audit-and-fix-workflow
- claude-code
- code-delegation
- github-pr-workflow
...
Only the listed skills get loaded into that profile's system prompt. Combined with the shared repository skill directory, this keeps each profile focused without duplicating skills across the filesystem.
Patches
Hermes 0.15.1 ships with bugs and missing features that matter at scale. Eight Python files in ~/Hermes/patches/ get bind-mounted over specific files inside the container at /opt/hermes/:
- ./patches/tool_guardrails.py:/opt/hermes/agent/tool_guardrails.py:ro
- ./patches/credential_pool.py:/opt/hermes/agent/credential_pool.py:ro
- ./patches/skill_utils.py:/opt/hermes/agent/skill_utils.py:ro
- ./patches/prompt_builder.py:/opt/hermes/agent/prompt_builder.py:ro
- ./patches/gateway_status.py:/opt/hermes/gateway/status.py:ro
- ./patches/kanban_tools.py:/opt/hermes/tools/kanban_tools.py:ro
- ./patches/hermes_state.py:/opt/hermes/hermes_state.py:ro
- ./patches/kanban_watchers.py:/opt/hermes/gateway/kanban_watchers.py:ro
What each fixes:
credential_pool.py: Z.ai SGT reset fix; the weekly limit reset was triggering at the wrong local time due to naive datetime handling
skill_utils.py + prompt_builder.py: the skills whitelist described above
gateway_status.py: virtiofs on macOS unlinks the lock file, which breaks get_running_pid() on restart
kanban_tools.py: makes kanban_list read-only for dispatcher-spawned workers
hermes_state.py: EIO/WAL crash on startup; deletes the stale SHM file so SQLite can reopen cleanly
kanban_watchers.py: false-positive "dispatcher stuck" alerts when per-profile spawn caps are in play
Memory
Three layers. MEMORY.md per profile, hard-capped at 2200 characters, injected into every LLM turn. It only holds behavioral rules — things that need to be true every single turn. The cap is intentional: larger MEMORY.md starts crowding out system prompt instructions.
Long-form knowledge goes into an Obsidian vault at ~/Hermes/obsidian-vault/. The top-level structure is directories like Architecture/, Operations/, Research/, Project/, Meta/, Security/, Strategy/, and so on. The Project/ subdirectory is a separate git repo backed up to Gitea nightly by planner. Inside Meta/hermes-learnings/ is where profiles store case studies and lessons from past sessions that are too detailed for MEMORY.md.
A cron syncs vault files to Hindsight every 30 minutes using mtime-based incremental ingestion with a 90-second wall budget. Profiles call hindsight_recall to pull relevant context on demand. This is additive: MEMORY.md still gets injected every turn; Hindsight adds three tools (hindsight_retain, hindsight_recall, hindsight_reflect) on top of that.
Cron jobs
Ten active ones on local-admin:
Gitea and backups
Gitea runs separately on port 8300 with an act_runner for CI. Three repos: hermes-config gets a daily auto-commit from launchd, the app repo gets pushed by coder on every task completion, and the Project/ section of the Obsidian vault gets pushed nightly by planner. Hermes has no admin access to Gitea anywhere, I keep that hard.
Three launchd plists on the Mac host handle the rest: hermes-bridge keepalive, git backup at 03:00, and kanban.db copy to host at 03:05.
Edit: oh and thanks to the Hermes maintainers, I submitted some bug fixes and feature requests and things get picked up very fast.
Edit 2: I had claude make a tutorial, this is one shotted so please validate things you are unsure about. Here is the link: https://claude.ai/public/artifacts/24a2fd0d-cda2-4e76-aad0-29f703482d5b
Edit 3: IMPORTANT ⚠️ this is nowhere near an example to follow. It is messy, has tons of security holes (which are kind of fine since it’s local), and the new Hermes version opens up so many improvements.
I shared this because someone asked about my set up. I’m not proud of, or confident in this. It is what I was running and it’s glued together with sugar. I already changed quite a bit of it and will now just take the same concept and see how I can apply it to 0.17.0
r/hermesagent
•
u/Nekew
•
Jun 14 '26
INTEGRATIONS — App connections, webhooks, API workflows Hermes Agent (and others) default Installs are silently routing web traffic to Parallel
EDIT - https://github.com/NousResearch/hermes-agent/pull/46350 Thank You to u/NousResearch and Teknium for your attention to this. I appreciate you coming into this thread and engaging with us directly.
****
A few days ago I noticed web_search and web_extract in Hermes Agent were hitting search.parallel.ai/mcp even though I never configured any backend or API key. I found out commit e0e2571 (PR #43798) has changed the without any disclosure that the author of the code works at Parallel.ai!
Here's what I found:
NormallyGaussian (Matt H,
[email protected]) = an employee of Parallel.ai, bio says "Currently at parallel-web"They've submitted 161 PRs across 14+ open-source projects, all adding Parallel as a web search/extract provider
In 9 of 10 merged PRs, the employment relationship was NOT disclosed
The Hermes PR that made Parallel the default was merged by the founder in 4.5 hours with 0 reviews
Same pattern in openclaw, centaur, massgen, opencode, agno, langchain docs, docker/mcp-registry, and more
Now there are copycat PRs from other people following the same playbook in other projects
https://gist.github.com/bdidur-nutripea/535ef422fb0f3a713ba2fc82cc1eeee5
https://github.com/NousResearch/hermes-agent/issues/45058
A fix PR (#45373) is sitting unreviewed at NousResearch/hermes-agent. If you use Hermes Agent and have not updated these settings, check your logs!
Hoping to put this in front of others! It was pretty disappointing to see my agent reaching out to a random company! At this point this company has infected too many projects for me to feel OK not posting about this.
EDIT: gist link, issue link
EDIT - Added Revert PR link @ top
r/hermesagent
•
u/SelectionCalm70
•
Apr 12 '26
Discussion — Opinions, comparisons, and ideas LLM cheatsheet for hermes agent
credits to the x post
r/hermesagent
•
u/rjn2-8
•
May 23 '26
Cost & Pricing — Token plans, API vs subscription, budget tips Deepseek v4 pro is unlimited and almost free OMG 😱 better than opus for me (I have no affiliate with deepseek, but you need to know this)
I just set 3 /goal not even 1$ used
r/hermesagent • u/StinkingHuntsman • Jul 17 '26
MODELS - model choice, routing, pricing, local vs cloud, VRAM Just tested Kimi K3 with Hermes. Lord.
I have Opencode Go so have a sliver of token quota for Kimi K3. Figured I'd point Hermes at a personal hardware display project that's been sitting unfinished for weeks because I kept procrastinating on the annoying parts.
It just... finished it.
Obviously it wasn't magic. It eventually hit the token limit instead of finishing everything. I have to review manually and go back to Deepseek v4 to complete. But it's gotten through a lot of bottle necks and that's... a lot more capable than I expected. I think Kimi K3 is up there with the current-gen AI big heads (Fable 5, GPT sol, GLM 5.2)
Kimi K3 + Hermes is a surprisingly capable combo. I didn't expect to be this impressed. For everyday usage, K3 is an overkill. But if you're trying to opimize your workflow or seeing things getting stale, try it and you won't regret it.
For anyone wondering, my setup is:
Hermes on a local Mac mini (M1 8GB RAM, $200 + ~20 watts per month)
Another Hermes instance on a LightNode VPS (2GB RAM @ $7/month)
OpenCode Go ($10/month)
GPT + Claude (ssh connection to VPS, $40/month in total)
I like having a dedicated remote box for long-running coding sessions instead of tying up my local machine. Since the VPS is hourly billed, I can spin one up for an experiment, let Hermes burn through hours of work, and delete it when I'm done. It's become a pretty comfortable workflow.
r/hermesagent
•
u/itsdodobitch
•
May 03 '26
Discussion — Opinions, comparisons, and ideas One month with Hermes Agent – what I wish I knew earlier
I’ve been using Hermes Agent for about a month, and the biggest surprise is not how hard it is to start.
It isn’t.
Hermes works impressively well out of the box. The work from u/NousResearch, u/teknium-official, and the contributors is already visible from the first run: skills, memory, session search, multiple providers, CLI and gateway support, and a system that is clearly designed to improve through use.
The real challenge starts after that first “wow” moment.
Because Hermes is powerful enough to make you overestimate how ready you are to use it properly.
That was my first lesson: don’t try to build the whole machine on day one.
It is very tempting to look at Hermes and immediately think:
“I can make this manage my inbox.”
“I can make this run my research workflow.”
“I can make this handle my TikTok profile.”
“I can make this organize half of my life.”
Maybe you can.
But not all at once.
Start with one small workflow. Make it boringly reliable. Then add the next piece. Then connect things. Hermes gives you enough power to scale quickly, but you still need to earn that complexity step by step. Understand what works, and let the system grow with you.
And don’t get too frustrated when it breaks.
It will. But that’s often where the useful part starts.
When you fix a broken workflow, you also make the original idea clearer: what the agent should do, what it should not do, which assumptions were too vague, and which steps needed structure.
That is usually when Hermes starts becoming closer to the agent you had in mind.
The second thing I wish I understood earlier: profiles are not just a convenience feature.
They are one of the cleanest ways to keep Hermes useful.
Don’t turn the default profile into a giant backpack full of every skill, every tool, every instruction, and every half-baked idea you had at 2am.
Segment things.
A research profile should not necessarily behave like a coding profile. A personal automation profile should not necessarily carry the same context as a writing profile. A focused Hermes is usually better than a “universal” Hermes that has to guess which version of itself you need.
This becomes even more important with skills/config/tools management. Choosing what stays in context is not just optimization. It is part of designing the agent.
The third lesson: config is not admin work. It is the product.
A lot of “Hermes is acting weird” moments are actually configuration moments.
Wrong assumptions. Missing settings. Too many things active at once. A parameter changed without really understanding the tradeoff. A profile that grew messy over time.
Before blaming the agent, inspect the environment you built around it.
And the funny part is that Hermes is very good at helping you understand Hermes.
Ask it to explain your config. Ask what each setting affects. And when something feels off, don’t just tweak things blindly: ask what might be causing that behavior.
That alone will save you a lot of random trial and error.
The fourth thing: don’t treat the skill system as an accessory.
It is closer to the core idea.
Hermes is not just “chat + tools.” The interesting part is that it can learn from usage, create skills, improve them, reuse them, and gradually turn repeated behavior into something more durable.
That changes the way you interact with it.
You are not only prompting an agent.
You are shaping an operating environment.
And every task you teach Hermes tends to expose something about your own workflow: where your instructions are vague, where your process is messy, where you thought you had a system but actually had a habit.
That part is underrated.
There’s also the new Curator feature, but it’s too new for me to say anything useful about it yet, so I’ll leave that out for now.
Last thing: share what you find.
Hermes is moving fast, and the repo reflects that. Recent releases brought things like Curator, improvements to the self-improvement loop, new bundled skills, more providers, gateway improvements, Spotify, Google Meet, Teams plugin, TUI improvements, performance work, and a lot more.
That kind of pace can be hard to follow alone.
But it becomes much easier when people post what they tried, what broke, what worked, what they misunderstood, and what finally clicked.
The contributor pool is already huge thanks to the maintainers and the people constantly testing, fixing, documenting, and improving the project. I’ve only contributed in a small way, but it was enough to see how much energy is moving around Hermes right now.
So if you find a useful pattern, a bug, a fix, a good profile setup, a strange edge case, or a small workflow that suddenly makes sense:
share it.
Open an issue. Open a PR. Post the config. Write the lesson down.
After one month, my biggest takeaway is this:
Hermes is not a setup you complete.
It is a system you learn how to grow.
r/hermesagent
•
u/Tarun122
•
Jun 08 '26
SHOWCASE — Projects, tools, builds, demos, GitHub repos My Hermes Agent is Managing a Youtube Channel lol
So I am indie developer who works on B2C apps and as you can guess the hardest part of my process is to find users for my apps.
I have tried many things so far but what I really wanted is to figure out a way to automate my marketing to a certain extent. And so I decided to give my hermes agent access to an youtube channel and runway api.
With some brainstorming around the type of videos I wanna post... it's now fully automated. My agents reflects on the performance of videos and plans next uploads accordingly.
It's only been 9 days so far and I have already cross 24K views on shorts and 29 subscribers on the channel. But more importantly more eyes on my startup.
I would love some tips from y'all if you have tried automated video generation yourself :)
r/hermesagent • u/Firm-Club-8334 • Aug 24 '26
MODELS - model choice, routing, pricing, local vs cloud, VRAM 😂 My god how on point this is
What are you guys doing to squeeze maximum tokens out of each dollar right now?
A colleague currently has 10 Claude Max 20x subscriptions.. I currently use gpt pro $200, opencode.ai a little bit and pivoting more and more to standardcompute.com to make the agent less wastefull
r/hermesagent
•
u/Jonathan_Rivera
•
Jul 06 '26
Discussion - Workflows, habits, setup, best practices Hermes Command Cheat Sheet - Every official slash command as of 7.4.2026.
r/hermesagent
•
u/itsdodobitch
•
Jun 17 '26
Discussion - Workflows, habits, setup, best practices three months with Hermes Agent: what i wish i had understood earlier
i just crossed three months with Hermes Agent, and three months in this reddit community.
i started on an old phone, back when almost nobody trusted this so-called new tool. then, after a few days, i realized how interesting this piece of software was becoming for me, and i switched to more appropriate hardware i bought just for it.
i stopped calling Hermes a “tool” about four weeks in. that was around the time i made my post “one month with Hermes Agent.”
i started to better understand where its answers were coming from, what context it was using, why some outputs worked, and why others didn’t.
it “remembered” what i had tried earlier only when i had given it the right structure to do so. it pushed back only when the setup made that possible.
btw three months. daily driver. here’s what’s actually different.
the elephant in the room
memory.
if you’ve tried Hermes, there’s a good chance you came for “the agent that remembers.”
nice, right? yes. but not in the way you expect.
i hit my head against this one for a while. tried every memory provider connected to Hermes, plus a few open-source ones from GitHub. in the end, i turned them all off.
there’s a reason “building your own memory plugin” became a thing lately. in my opinion, it’s because all of them come with downsides. for me, more downsides than upsides.
and i think NousResearch knows this.
the markdown USER / MEMORY / SOUL system Hermes comes with is probably the best setup. USER and MEMORY are short and editable by the agent. SOUL stays immutable.
leave it there. inspect it. clean it when something wrong gets in. tweak it on purpose to see how the agent changes. but that’s it.
it taught me a lot. and it killed the magic of “agents that remember.”
agents don’t remember. agents read.
6 profiles became 3
i’ve always argued that profiles, in Hermes, are one of the foundations you need to understand and configure with care. it's definitely important, deciding which tools, skills and context each one of your agents has its basically half the job. but maybe, at some point, i got a little carried away:
one default. one for code. one for research. one for my girlfriend. one archiver. one for “experiments.”
yeah, too much.
now, three months in: three profiles, scoped hard. each one is a real “colleague” with its own voice and stack.
the pruning wasn’t a magic moment. it was just obvious, eventually.
if you only take one thing from this: do the cut. if you have more than 4 profiles, you probably have more than you need.
the terminal got quiet
the first instinct for any task, big or small, is: “can Hermes do this?”
sometimes the answer is no, and i do it myself. most of the time, the answer is: “yeah, describe it,” and i move on.
sounds small, but i’m not typing raw commands anymore. not so often.
starting a task became almost free (time speaking). the work shifted to describing it well. a very different sensation. much less scary.
this is the incredible part
it runs on a $50 raspberry pi 4. it has not blinked. and i got it for free.
i want to repeat this: it’s completely free to download. you just pay for what you use, and you decide where your money goes. or, if you are skilled and well equipped, you run everything locally and let the world burn around you without caring much.
thank you open source. thank you NousResearch.
so three months. no crashes. no update broke anything (hi OpenClaw). no mysterious regressions.
the same uptime counter, running on the same $50 board with 8GB of RAM, hosting an agent that has become my primary interface to my own machine.
the cloud-based tools i use change pricing, deprecate API, ship breaking changes, and occasionally go down.
Hermes just runs.
quietly.
for ninety days.
on hardware that costs less than dinner.
so, what can Hermes actually do?
and when do you “master” it?
i don’t know.
i only know what these three months did to me. they rewired my workflow, forced me to learn faster than i expected, and made me understand things i would have probably ignored for years. i tested, broke things, rebuilt them, changed my mind, changed it again.
and somewhere in that process, i started feeling part of a community that, at least from where i’m standing, is redefining how humans interact with technology.
and maybe that’s fine.
thanks to u/NousResearch, u/teknium-official, the guys running this community and everyone shipping this thing daily.
hoping for an even brighter future.
r/hermesagent • u/kaishi00 • Oct 12 '26
Showcase Hermes Conduit 0.1.17 (UPDATE): Your agent can call you now. Apple Watch voice, too.
Conduit 0.1.17 is out on the App Store.
Yes, another update already. Apparently I can't leave voice alone. 😂
Last update was about making Hermes feel more like an actual voice assistant. This time I figured, why am I still checking whether my agent finished working? Why can't it just call me?
Well, now it can.
Hermes calls you
You can start a Live Voice session, hand Hermes a long-running task, ask it to call when it's finished, and hang up. You can also trigger it from a cron, use some imagination on what you can do!
Hermes keeps working after the conversation ends. When it's done, Conduit can ring your phone using the native iOS incoming-call interface.
Answer the call and continue the conversation instead of opening the app, finding the session, and figuring out where you left off.
This also opens up other possibilities, like having Hermes call when it needs your attention rather than hoping you notice a notification.
To clarify, this uses native iOS calling integration through CallKit. Hermes isn't dialing your cellular phone number.
Apple Watch voice
You can also talk to Hermes directly from your Apple Watch.
The idea is to make Hermes available without needing to pull out your phone every time. With incoming agent calls, you can answer from your wrist and deal with whatever Hermes needs.
It's the same Hermes backend, with access to your existing tools and workflows, not a separate chatbot running on the watch.
Important: update the notifier plugin
If you use the Conduit companion/notifier plugin, make sure it's updated. The incoming-call features depend on the newer plugin capabilities. The plugin also comes with bundled skills, so make sure you restart your gateway and dashboard.
You'll also need your own Hermes instance and a configured voice provider. Conduit is the client, not a hosted AI service.
And yes, there's a beach episode
I spent an unreasonable amount of time making an anime beach episode to demonstrate an AI agent calling me about a completed GitHub PR.
At this point I'm just committing to the bit. 😂
The attached video is a promotional animation, not a literal screen recording (obviously).
Links
App Store: https://apps.apple.com/app/hermes-conduit/id6790977764
GitHub (app): https://github.com/kaishi00/hermes-conduit
GitHub (notifier plugin): https://github.com/kaishi00/hermes-conduit-notifier
Website: https://hermesconduit.app
Previous 0.1.16 update: https://www.reddit.com/r/hermesagent/comments/1wyq6kt/hermes_conduit_0116_update_handsfree_voice_grok/
As always, Conduit is free, open source, MIT licensed, with no ads or tracking. It connects to your own Hermes backend.
And yes, 0.1.18 is already submitted with some follow-up bug fixes. Apple apparently reviews these faster than I can stop adding things.
Feedback and bug reports are welcome, preferably on GitHub so I can keep track of them.
Now I'm going to sleep. Enjoy the beach episode. 😂
r/hermesagent • u/raruto_ • Jun 21 '26
OTHER - Fallback if nothing else fits Imagine this was 2010 and you just got your hermes cd
r/hermesagent • u/SelectionCalm70 • Jun 02 '26
NEWS & UPDATES — Releases, announcements Nous Research Just Launched Hermes Desktop Native Cross-Platform App for the Self-Improving Hermes Agent (macOS, Windows, Linux)
The team at Nous Research just dropped Hermes Desktop in public preview bringing their powerful open-source Hermes Agent into a polished native GUI app that runs locally on your machine.
Download link
r/hermesagent
•
u/HolmeBengt
•
Jun 23 '26
USE CASE - Real-world tasks, business uses, personal workflows I've been asked many times what my Hermes actually does 😉 so I will explain! And as you know by now I will spare no details.
I run 28 cron jobs and 30+ custom skills. Every single one was built with Hermes, not downloaded. This is exactly what they do and how they work.
🌙 Dreaming — The Memory Hack
Every night at 3 AM while I sleep, Hermes reads every single conversation we had. It extracts the decisions made, projects worked on, bugs chased, people talked to, and mistakes that should not be repeated. Then it writes a structured summary to a file that loads automatically at the start of every session. That's the key insight — not the summarization itself, but where the output lands. Before Dreaming, if I coded for four hours and went to bed, Hermes woke up with zero memory of it. Now it knows exactly where I left off and what needs to happen next. But that's still a work in progress — memory still isn't perfect.
📬 Mail Gatekeeper — Secure Inbox Filtering
Four inboxes, one local AI judge running entirely on my Mac Mini via Ollama. Every incoming email gets classified as safe or blocked. Blocked means: 2FA codes, login confirmations, password resets, bank transactions, spam — all quarantined to a blocked folder. Safe emails land in a Telegram topic where I can see that they have been let through. There is no send endpoint anywhere in the system — Hermes can read and draft, but nothing can physically leave the machine. A watchdog reviews every blocked email each evening to catch false positives. No mail data ever touches an external API. That's the security model I'm comfortable with. This runs on two different users on my Mac Mini so they are completely disconnected — if you're curious, I've made a post about that.
🥗 Health Coach — Daily Nutrition & Recovery
Every day at noon, Hermes collects three data streams simultaneously. My WHOOP recovery score, strain, sleep quality, and HRV. My Apple Health steps and resting heart rate. And everything I've eaten so far that day logged through the food tracker — just a skill I created with Hermes. I tell him what I ate that day as precisely as possible, so with weight, and it tracks it. It cross-references all three against my lean bulk targets — 2,300 calories and 150 grams of protein — calculates my remaining macros, and delivers tailored coaching. What's looking good, what needs adjustment, and specific meal suggestions that fit my remaining budget. The food tracker itself is a SQLite app Hermes built for me. I log meals via Telegram with text, photo, or barcode scan, and it parses macros automatically using AI. There's a widget on my iPhone lock screen showing exactly how many calories and grams of protein I have left. The widget uses the iOS app Scriptable.
📚 Study Audit — What I Actually Learned
I time every study session in Toggl Track. At 9 PM, Hermes pulls all entries, groups them by subject — Math, Accounting, Cost Accounting, General Business Administration, Law, English — and tells me what I studied and for how long. But duration alone tells me nothing about coverage. So I also maintain a Notion database with chapter-level checkboxes for each class. As I study, I check things off. Hermes queries both data sources, cross-references them, and produces a combined report: what I studied, how long, which chapters I completed, and what's still pending. I get a complete daily learning audit every single night.
💰 Finance Review — Weekly & Monthly
All my finances live in MySalary, a finance dashboard I built myself and host on my VPS. Every Sunday at 6 PM, Hermes hits the API and pulls my live income, expenses, liquid assets spread across all my accounts, and my investment portfolio. It calculates burn rate, compares against my budget split, and delivers a clean weekly snapshot. On the 28th of every month at 8 PM, I get the full treatment: profit and loss statement, month-over-month variance, net worth trajectory, and savings rate analysis. Both delivered with voice.
🧠 Wisdom Vault — Auto-Capture to Spaced Repetition
Every time I send Hermes an insightful link, a voice message with a business lesson, or a noteworthy quote, it automatically extracts the key wisdom and saves it to a Notion database with the source, my commentary, and a category tag. On Sundays, Hermes reviews the full vault, picks what's worth memorizing, and generates Anki cards with cloze deletions or question-answer format. Those cards sync to my iPhone and appear in my daily reviews. Every insight I encounter becomes a permanent spaced-repetition asset that I actually remember.
💬 Writing improvement — The Feedback Loop
Every time I correct something Hermes wrote — an email, a message, a post — the before-and-after gets saved to Notion with notes on what was wrong and why my version was better. On Saturdays, Hermes analyzes the full collection looking for patterns in my corrections. Too many filler words. Too formal for Telegram. Over-explains things. Then it updates its own system prompt to fix those patterns permanently. Every single correction makes my future writing slightly better. I never have to repeat the same feedback twice.
🖥️** Infrastructure Monito**ring
Every four hours, Hermes checks whether all five of my hosted websites are reachable, whether Coolify on my VPS is running properly, and whether fail2ban has flagged anything suspicious. The Mac Mini itself gets temperature-logged throughout the day, since I run Ollama 24/7 and thermals matter. If a site goes down or temperatures hit concerning levels, I get an immediate alert. The entire Hermes configuration gets compressed and backed up to iCloud every morning automatically.
📋 Daily Status Report
Each morning at 6:30, I get a compact status briefing. Today's calendar events and what needs preparation. Open to-do items that require attention. System health — disk usage, memory pressure, uptime, VPS site status. Any anomalies from the overnight Dreaming run or error logs. This is not the news. This is the tactical dashboard telling me what needs my attention before the day starts.
⚠️** What Still Doesn't Work Gre**at
Long-term memory is still the biggest unsolved problem. Dreaming helps, but session-to-session recall remains inconsistent. I built an Obsidian integration following the popular approach, but Hermes rarely reaches for it naturally — it sits there unused most of the time. Thirty-plus skills means thirty-plus things that can break when APIs or Hermes itself updates. Mail polling adds two minutes of latency, which occasionally misses urgent messages. I'm still iterating on all of these.
🔧 How I Build These Things
I outline the goal and my constraints. Hermes drafts an approach with API choices and architecture options. I review it, make changes, and ask for simplification. Then we build the first version. I test immediately — because it never works the first time. Then we fix and simplify again. Each skill is one file, one job, no dependencies. That's the whole process.
I've downloaded skills from repositories and marketplaces. They never worked as well as what we built ourselves. Self-built tools fit your workflow organically because they grew out of it. When they break, you understand what's wrong because you shaped them. And they get better with every iteration.
That's the full picture. Twenty-eight automated jobs running around the clock, from Dreaming at 3 AM to the study audit at 9 PM. A complete digital nervous system for my student life, business, health, and finances.
Ask me anything about any of these — happy to share the exact prompts, approaches, and lessons learned. Building in public 💪
This is the blog post going even more in-depth: https://blog.holmebengt.com/post.html?id=hermes-full-setup&utm_source=reddit&utm_medium=post&utm_campaign=what-my-hermes-does
r/hermesagent • u/Free_Tennis7754 • Jul 03 '26
Discussion - Workflows, habits, setup, best practices Hermes for Passive Income Spoiler
Hermes is making some sweet money on autopilot.
Zero maintenance.
99.66% profit margin.
$71.36 in June.
Already $6.84 in 3 days of July
How?
Selling API on Apify
Just tell Hermes to learn about Apify
Then, create some actors.
Ideally, do research, but you can start with whatever you like.
Expect 80/20, where 20% of actors will bring you 80% of revenue.
Create a lot - let them marinade for a few month.
Keep the profitable ones, kill the rest, and create more.
???
PROFIT!
Are y'all making money or are you just burning tokens?
r/hermesagent • u/sixteenpoundblanket • 5d ago
Showcase Hermes with craft-anything is magical
craft-anything is the tool used by the people who cloned every Adobe app:
https://github.com/storytold/craft-anything
I asked Hermes to install it, learn how to use it and make it available as a skill. It did all that of course.
Then I asked Hermes to clone an application, both web based and Android phone versions. This is an app I pay $60/year for - highly polished, complicated app, not a basic open source thing.
Hermes went to work, used craft-anything, and in about 12 minutes I had basic working versions with nearly identical look and feel. I had also asked Hermes to monitor total cost - I'm using deepseek flash only, direct API. It was $0.62 (62 cents).
Hermes then adujsted a few things, added new features that I wanted that were not in the original app, and offered suggestions for some new things I had not thought of. Nothing short of astounding.
All of this makes me wonder about the state of commercial software development in the near future. The pace of increased capabilities of models/harnesses is hard to even keep up with.
r/hermesagent
•
u/Stephen_Falken_1983
•
Jun 25 '26
SHOWCASE — Projects, tools, builds, demos, GitHub repos Sharing my totally nutty Hermes setup
Friday June 26 EDIT: Based on a very unexpected level of interest, but I am excited to announce that I will be open sourcing the Joshu stack!! 🎉
I will need a few days to clean up the codebase, and several expressed interest in following along in the progress and/or contributing -> please go here: https://www.reddit.com/r/joshu_backrooms
I'll continue to post more general Hermes stuff here where it makes sense, but I'll keep content specific to Joshu over there. 🙏
---------
Hey all, thought I would share the setup under my cloud based Hermes service: Joshu. (I am purposefully not sharing the address for the service as I have no interest in trying to promote it, just genuinely looking to share what I have learned!)
My goal was to really push the envelope on the 'multi modality' of talking to Hermes, and to totally rethink the user experience of something well past chat. The video has a few lengthy demos, but the salient points are below.
1. LLM: I use Deepseek v4 Flash via Openrouter. Dealing with LLMs used to drive me crazy, between cost, intelligence, speed, censorship, etc. That's a thing of the past.
2. HERMES HARNESS: The LLM is wrapped in Hermes, which manages multi-gateway communication (chat, SMS, iMessage, telephony, voice). Hermes routes incoming messages to the LLM and handles structured skill execution.
3. DEDICATED CLOUD BOX (DigitalOcean VPS): The entire system runs on a dedicated Ubuntu VPS (DigitalOcean), not shared infrastructure. Each user gets their own box with dedicated CPU, GPU, RAM, and disk. There is a control plane app on Vercel that manages boxes.
4. GBRAIN SEMANTIC FILE SYSTEM: The Linux file system is augmented with GBrain (by Gary Tan), a semantic indexing layer. Every file Joshu creates, every email thread saved, every document you upload gets indexed. The LLM can query files both with traditional terminal commands (grep, ls) AND via semantic vector search, so Joshu can find relevant files by meaning, not just filename.
5. HINDSIGHT MEMORY SYSTEM: Hindsight is wired in as the memory provider. I really didnt mess with it at all, it pretty much worked out of the box.
6. SKILL LIBRARY: In addition to the standard Hermes learning loop, the box reports back to the control plane any long sessions, which then gets stored in git. I manually inspect these as potential red flags of the system going astray.
7. THE CLOUD DESKTOP (LGUI 'Language Graphical User Interface'): This is Joshu's most unique feature. Rather than a chat interface, Joshu has a full cloud desktop: a GUI running on the VPS that both the human AND the AI agent can operate simultaneously. Apps on the desktop (email client, file browser, whiteboard, web browser) have language pipelines built in, so Joshu can open, read, and interact with them programmatically, while you can also use them like a normal desktop app. This solves a fundamental problem with "computer use" AI: those systems try to control a Mac or Windows desktop designed for a mouse, keyboard, and human eyes. Joshu's cloud desktop is purpose-built for joint human-AI operation from the ground up.
8. HYBRID WEB BROWSER: Joshu includes a sandboxed browser-within-a-browser. It doesn't share cookies with your local Chrome, but it IS logged into your accounts (Facebook, Gmail, etc.). This lets Joshu handle tasks that require authentication — a hard blocker for most agent systems that can't get past login screens or 2FA without a human in the loop.
Timestamps
0:00 - Demo begins: calling Joshu, walking out to the cloud desktop
0:53 - Cloud desktop overview: file system, email, connected accounts, chat & voice
4:23 - Time block plan: Joshu reads calendar and builds a prioritized daily schedule
6:37 - Hindsight memory system: how Joshu remembers context across sessions
7:27 - File Brain / GBrain: semantic file indexing on the local desktop
8:09 - Hybrid web browser: agent + human browsing, sandboxed and session-aware
9:35 - Facebook Marketplace demo: Joshu autonomously updates a listing and emails confirmation
10:04 - Technical deep-dive: LLM kernel, Hermes harness, GBrain, Hindsight, and the LGUI architecture)
Ask me any questions! Anything I can improve on?
r/hermesagent • u/Jonathan_Rivera • May 22 '26
Cost & Pricing — Token plans, API vs subscription, budget tips DeepSeek v4 pricing change
I actually like the pro model and hit $14 vibe coding last night using open router which is still around $3.50 ish. It looks like you have to sign up direct with api billing. It’s china so data retention is a thing.