Hermes Agent might have just killed OpenClaw

One Sentence Summary

This video argues Hermes Agent is more reliable and feature-rich than OpenClaw, detailing seven new capabilities and workflows for creators.

Main Points

• Hermes dashboard introduces the Canban board for multi-tasking.
• OpenClaw issues include daily updates that break functionality and cause bloating.
• Hermes updates are fewer, more focused, and reliably fitting a narrative.
• The Canban workflow moves tasks from triage to done with automation.
• Tasks are auto-filled with Obsidian memory context for relevance.
• A separate librarian agent handles board automation to avoid bottlenecks.
• Slashgoal enables high-level, multi-step missions over long periods.
• Profiles / multi-agents let you create specialized agents (coding, research, admin).
• The model catalog simplifies model switching and cost tracking.
• Hermes uses a curator that prunes unused skills to reduce bloat.

Takeaways

• Set up a dedicated librarian agent to manage the Canban board cron tasks.
• Use slashgoal with a strong metaprompt for effective long-term agent missions.
• Create separate agents for coding, research, and admin to prevent memory bloat.
• Enable and tune compression thresholds to balance memory usage and performance.
• Rely on the curator to prune unused skills and maintain lean, fast behavior.

---

Summary

The transcript explains how to use Hermes Agent as a more reliable alternative to OpenClaw, focusing on multi-agent workflows, task automation, and long-running goal execution. The core problem addressed is inefficient, single-threaded agent workflows and instability in competing tools. Hermes solves this through:

• A Kanban-based task orchestration system
• Cron-driven automation
• Multi-agent (profile-based) architecture
• SlashGoal (/goal) long-running missions
• Model management + memory optimization

The tutorial is highly implementation-focused, showing how to build a fully automated task pipeline using Hermes CLI, dashboard, and custom prompts.

Source:

---

Detailed Step-by-Step Breakdown

1. Launch Hermes Dashboard

Command:

hermes dashboard

Process:

1. Open terminal (CLI)
2. Run command above
3. Hermes returns a local URL
4. Open URL → access dashboard UI

---

2. Use Kanban Board for Task Orchestration

Default Columns:

• triage
• todo
• ready
• in progress
• blocked
• done

Workflow:

1. Add tasks in triage

2. Example tasks:

   • "Discuss hiring with AI"
   • "Message livestream clippers"
   • "Plan second channel"

3. Wait for automation (cron job)

4. Tasks automatically:

   • Enriched with context
   • Moved → ready

---

3. Automate Task Enrichment with Cron Job

Core Prompt (IMPORTANT):

I want to work on the kanban board inside the Hermes dashboard. 
Please create a cron job that checks the kanban board every 10 minutes 
to see if there are any tasks in triage. Then take the tasks, look through 
all the memories, and fill out the details for the task. Then move it into ready. 
Then check to see if there are any tasks in ready that I assigned an agent to. 
If I did, take care of that task.

Execution Flow:

1. Cron runs every 10 minutes (configurable)

2. Agent:

   • Reads tasks in triage
   • Pulls context from memory (e.g., Obsidian vault)
   • Expands task details
   • Moves → ready

3. If assigned → executes task

---

4. Create a Dedicated “Manager Agent” (Recommended)

Why:

• Prevent blocking main agent
• Separate orchestration from execution

Steps:

1. Ask Hermes:

Create a new agent profile called "Librarian"

1. Assign responsibilities:

   • Cron job execution
   • Task enrichment
   • Memory lookup

Model Recommendation:

• Use cheap model (e.g., ChatGPT O3/O1 equivalent)
• Reduces cost for frequent cron runs

---

5. Assign Tasks to Worker Agents

Manual Step:

1. Open task in ready

2. Assign agent (e.g., “Hermes”)

3. Agent automatically:

   • Moves task → in progress
   • Executes
   • Logs output in comments

---

6. Use /goal for Long-Running Missions

Command:

hermes

Then:

/goal <your mission>

Example:

Audit my Obsidian vault, find outdated or orphaned notes, and create a cleanup plan.

Behavior:

• Multi-step reasoning
• Self-evaluation loops
• Runs for minutes → days
• Acts like an autonomous execution loop

---

7. Improve /goal Results via Meta-Prompting

Recommended Workflow:

1. Go to external LLM
2. Prompt:

Generate a detailed slashgoal prompt for this objective: <goal>

1. Paste result into Hermes

---

8. Create Multi-Agent System (Profiles)

Steps:

1. Dashboard → Profiles → Multi-agents
2. Click “Create”
3. Configure:

Suggested Agents:

• Main Orchestrator
• Coding Agent
• Research Agent
• Administrative Agent (Librarian)

Key Benefit:

• Isolated memory per agent
• Prevents context bloat
• Improves performance

---

9. Configure Model Catalog

Capabilities:

• Assign models per task type
• Track cost usage

Example Setup:

• Expensive model → planning
• Cheap model → execution tasks

Pattern:

• “Brain” model (orchestrator)
• “Muscle” models (workers)

---

10. Optimize Memory Compression

Issue:

• Default compression = aggressive (data loss)

Fix:

config → compression → threshold = 0.5

Effect:

• More frequent compressions
• Less data loss per compression

---

11. Understand Curator System (Auto Optimization)

Default Behavior:

• Runs every 7 days

Function:

• Analyzes skill usage
• Removes unused skills
• Generates usage report

Optional Config:

config → curator → frequency

---

Key Technical Details

• CLI Command: hermes dashboard
• Agent Command Mode: hermes
• Goal Execution: /goal
• Cron Frequency: default suggested = 10 minutes
• Compression Setting: threshold = 0.5
• Curator Cycle: 7 days (default)
• Multi-Agent Isolation: separate memory + env per profile
• Task Flow Automation: triage → ready → in progress → done
• Memory Source Example: Obsidian vault integration
• Execution Logs: stored as task comments

---

Pro Tips

• Use a dedicated low-cost agent for cron automation
• Keep main agent free for heavy tasks
• Always meta-prompt /goal inputs for better results
• Use Kanban + multi-agent combo for true parallelism
• Lower compression threshold early to avoid memory loss
• Assign specific roles per agent (don’t generalize)
• Use curator reports to manually refine skills
• Run frequent cron jobs if using cheap/local models

---

Potential Limitations/Warnings

• Memory Compression Weakness

  • Can cause loss of important context

• Poor /goal prompts = poor outcomes

  • Requires detailed input

• Single-agent overload risk

  • Avoid doing everything with one agent

• Cron misconfiguration

  • Too frequent → unnecessary cost

• Long-running /goal tasks

  • Can consume significant tokens

• Dependency on memory quality

  • Bad memory = poor task enrichment

---

Recommended Follow-Up Resources

• Hermes CLI documentation (for command reference)
• Obsidian knowledge management workflows
• Prompt engineering for autonomous agents
• Multi-agent system design patterns
• Cost optimization strategies for LLM pipelines

---

Suggested Books (5)

1. Designing Data-Intensive Applications — Martin Kleppmann Paperback, Kindle, Audiobook Explains how to design scalable, reliable systems—highly relevant for building multi-agent architectures like Hermes workflows, especially around task orchestration and state management.

2. Artificial Intelligence: A Modern Approach — Stuart Russell & Peter Norvig Paperback Provides foundational understanding of agent-based systems, planning, and decision-making, which directly supports understanding how /goal execution works internally.

3. Building Microservices — Sam Newman Kindle, Paperback Helps conceptualize each Hermes agent as a microservice with isolated responsibilities, improving reliability and scalability in multi-agent setups.

4. Prompt Engineering for Generative AI — James Phoenix & Mike Taylor Kindle, Paperback Directly applicable to improving /goal prompts and meta-prompting strategies for better autonomous agent performance.

5. The Pragmatic Programmer — Andrew Hunt & David Thomas Kindle, Hardcover Covers practical engineering discipline, automation, and workflow optimization—key to building efficient AI-driven pipelines like the Kanban + cron system described.