Hermes Agent Real-World Workflow: A Developer's Complete Routine from Install to Daily Use

The first four articles covered all of Hermes's core components — Skills system, persistent memory, Cron / Delegation / Code Execution.

But a component list isn't a workflow. Knowing what Hermes can do and knowing "how to use it in my daily work" are two different things. This article goes straight to the scenarios.

The First 15 Minutes After Installation

Install first, then worry about the rest:

pip install hermes-agent
hermes chat

Once inside, don't rush to make it do anything. First ask it to introduce itself:

What skills do you have?

It will list the built-in skill index. Scan which skills are relevant to your work — this determines whether you need to install additional things from the Hub.

Then configure the LLM:

hermes model

Select your provider (Anthropic, OpenAI, Google, Ollama, any OpenAI-compatible API), set the API key, done.

Finally run a basic health check:

hermes chat -q "What tools do you have available? List them by category."

If the tool list looks right and the agent responds, the installation is solid.

Scenario 1: Daily AI Tech Summary, Auto-Sent to Telegram

This is the fastest way to feel Hermes's value — set it up once, never manage it again.

Step one, set up Telegram integration:

hermes platform add telegram
# Follow the prompts to enter your bot token

Step two, set up the scheduled task:

hermes cron add "0 8 * * 1-5" "Create a technical briefing for a software engineer. Search for:
1. Top AI/LLM news from past 24 hours (focus: open source models, agent frameworks)
2. Top developer tools/productivity news from past 24 hours
 
Format as clean markdown with section headers. Include source links. Keep each item under 50 words. End with a one-line motivational note." --platform telegram

Confirm the task exists:

hermes cron list

After that, every weekday morning at 8am, Telegram receives a technical briefing. No presence required, nothing to open.

Scenario 2: Making Hermes Remember Your Project

At the start of a new project, spend 5 minutes letting Hermes learn the environment — every session after that needs no re-briefing.

Just tell it directly:

hermes chat -q "Please remember the following about my current project:
- Project: ~/code/api-service, Go 1.22, chi router, sqlc for DB queries
- Run tests: make test
- Staging deploy: ssh deploy@10.0.1.50 -p 2222, key at ~/.ssh/staging
- Database: PostgreSQL 16 on staging, port 5433
- CI: GitHub Actions, auto deploy to staging on push to main"

Hermes will write this information to MEMORY.md. The next time a session starts, these facts are in its system prompt — no need to repeat them.

When to update memory:

Environment changes (changed port, new key, new service)
Project conventions get updated
You corrected one of its behaviors ("don't do it that way, do it this way")

Scenario 3: Running Hermes + Claude Code Together

This is a combination many people haven't considered, but it's actually very natural — they solve different layers of the problem, not competing with each other.

What Claude Code does: Write code inside a codebase — diff previews, inline editing, file context integration. For that in-IDE experience, Claude Code is still smoother.

What Hermes does: The places Claude Code can't reach — cross-session memory, scheduled tasks, Telegram delivery, parallel sub-agents, switching between any LLM provider.

How they actually work together:

After finishing a feature in Claude Code, jump to Hermes for an overall review and checklist:

# In Hermes
hermes chat -q "Review the changes I just made to ~/code/api-service. 
Check for: security issues, missing error handling, performance concerns. 
Then update MEMORY.md with any new conventions I introduced."

Or let Hermes handle "AI tasks outside of development work" — morning briefings, weekly report generation, scheduled monitoring — while Claude Code continues to handle day-to-day development.

You don't have to choose one. Their positioning doesn't overlap, but combining them is more complete than using either one alone.

Scenario 4: Build Your Own Skill to Lock In Common Workflows

You have a fixed staging deployment workflow that requires typing a bunch of commands every time — save it as a skill:

mkdir -p ~/.hermes/skills/devops/deploy-staging

---
name: deploy-staging
description: Deploy service to staging environment with health check and rollback
cover: "/images/en/hermes-agent/05-hermes-agent-real-world-workflow.png"
version: 1.0.0
metadata:
  hermes:
    tags: [deploy, staging, devops]
    category: devops
    requires_toolsets: [terminal]
---
 
# Deploy to Staging
 
## When to Use
When deploying updates to the staging environment, or manually triggering a staging deployment.
 
## Steps
1. Confirm you're on the correct git branch: `git branch --show-current`
2. Pull latest code: `git pull origin main`
3. Run tests: `make test` — stop if it fails
4. SSH to staging: `ssh deploy@10.0.1.50 -p 2222 -i ~/.ssh/staging`
5. Pull latest image on staging: `docker compose pull`
6. Restart services: `docker compose up -d`
7. Wait 20 seconds, verify health: `docker compose ps`
8. If any unhealthy, rollback: `docker compose down && docker compose up -d --no-pull`
 
## Known Pitfalls
- Staging SSH uses port 2222 not 22 — commonly forgotten
- Health checks sometimes take more than 30 seconds to show healthy; don't declare failure too early
 
## Verification
`docker compose ps` shows all services running, no unhealthy.

Once saved, deploying is just:

/deploy-staging

Same workflow every time — never forgets the health check, never skips the tests.

Advanced: Generate Weekly Reports with Delegation

hermes chat -q "Generate this week's engineering summary by delegating to 3 parallel agents:
1. Delegate: Summarize all commits to ~/code/api-service this week (git log --oneline --since='7 days ago')
2. Delegate: Check all GitHub Actions runs this week and report success/failure rate
3. Delegate: List any new dependencies added to go.mod this week
 
Combine into a structured weekly report with sections: Deliverables, CI Health, Dependencies."

Three sub-agents each run their own tasks, the main agent waits for all to finish then aggregates — this type of fixed-format weekly report, set as a Cron task, auto-generates every Friday.

A Checklist: Things You Can Do Right Now

After installing Hermes, work through this in order:

✅ Install, run hermes chat, confirm basic functionality works
✅ Configure your LLM provider with hermes model
✅ Browse the skill index: "What skills do you have?"
✅ Tell Hermes about your work environment so it can save it to memory
✅ Set up one Cron task — even just a daily morning news briefing
✅ Find a workflow you repeat often and write it as a skill
✅ If you use Telegram, connect it

No need to do everything at once. Every step has independent value; completing one delivers returns immediately.

One Last Thought

Hermes Agent's learning curve is real — there are Skills, a memory system, and automation as three separate systems, each with its own logic to understand.

But the problem it solves is also real: there are too many AI tools, each covering only one slice, and none of them are helping you integrate "AI capabilities" into "cross-platform, cross-session, memory-enabled, schedulable complete agent infrastructure."

Hermes is the closest open-source framework I've seen to achieving that goal. The learning investment is worth it.