Hermes — 1 Documents
Full Reference: CLI, Slash Commands, Config, Providers, Toolsets
📄 AI Orchestration with Hermes Agent — 994 lines
A Comprehensive Guide to Enterprise AI Orchestration — From Single Agents to Multi-Agent Workflows
1. Introduction to AI Orchestration
1.1 The Evolution of AI in the Enterprise
Enterprise AI adoption has evolved through distinct stages:
| Stage | Era | Paradigm | Example |
|---|---|---|---|
| ChatGPT Era | 2022 | Human asks, AI answers | Single-turn Q&A with ChatGPT |
| Copilot Era | 2023 | AI assists human tasks | GitHub Copilot, Microsoft Copilot |
| Vibe Coding | 2024 | AI builds from description | Cursor, Claude Code, Windsurf |
| Agentic Workflows | 2024-2025 | AI executes multi-step tasks | ReAct agents, tool use |
| Multi-Agent Fleets | 2025 | Specialized AI agents collaborate | CrewAI, AutoGen, LangGraph |
| AI Orchestration | 2025-2026 | Master agent manages AI agents | Hermes Agent |
| AI Economy | 2026+ | Agents transact autonomously | x402 protocol |
AI Orchestration represents the sixth stage — where a central intelligent system coordinates multiple specialized AI agents, tools, and data sources to accomplish complex business objectives autonomously.
1.2 Why AI Orchestration Matters for Enterprises
Modern enterprises face several challenges that AI orchestration addresses:
- Tool proliferation: Teams use 10+ SaaS tools (CRM, ERP, project management, monitoring, communication platforms). An orchestrator unifies them under one AI interface.
- Knowledge fragmentation: Critical information lives in silos — documents, databases, chat logs, email. Orchestration enables cross-system retrieval and action.
- Repetitive workflows: Deployment, monitoring, reporting, and compliance checks follow predictable patterns that can be automated.
- Decision latency: Days or weeks pass between identifying an issue and resolving it. Orchestration compresses this to minutes.
- Cross-functional coordination: Tasks often require input from multiple departments. An orchestrator can parallelize across domains.
2. AI Agent vs AI Orchestrator
2.1 What is an AI Agent?
An AI Agent is an autonomous software entity that:
- Perceives its environment (files, APIs, databases)
- Reasons about goals using an LLM
- Takes actions using tools (terminal, API calls, file operations)
- Observes results and adjusts its approach
The core agent loop is:
Observe → Think → Act → Observe → Think → Act → ...
This is formalized as the ReAct pattern (Yao et al., 2023):
Thought: I need to find the root cause of this error
Action: read_logs("/var/log/app.log")
Observation: NullReferenceException at line 142
Thought: The error is a null check missing before property access
Action: edit_file("src/Service.cs", "if (result == null) return NotFound();")
Observation: File updated
Thought: I should verify the fix compiles
Action: run_command("dotnet build")
...
Key characteristics of an agent:
- Single-task focused (or narrow scope)
- Sequential execution
- Limited context window
- Uses tools for specific operations
- May have basic memory (session-based)
2.2 What is an AI Orchestrator?
An AI Orchestrator is a meta-agent that manages the entire lifecycle of complex, multi-step objectives by delegating to specialized sub-agents, tools, and systems.
Core capabilities:
| Capability | Description | Impact |
|---|---|---|
| Goal Decomposition | Breaks complex goals into manageable sub-tasks | Handles objectives too large for single agents |
| Parallel Delegation | Spawns multiple sub-agents simultaneously | Reduces execution time from linear to logarithmic |
| Cross-Session Memory | Remembers context, preferences, and decisions across sessions | Eliminates repetitive explanations |
| Skill Management | Creates, stores, and reuses procedural knowledge | Efficiency improves with use |
| Cron Scheduling | Runs recurring tasks autonomously | "Set and forget" automation |
| Multi-Platform Delivery | Sends results to any channel (CLI, Telegram, Discord, email) | Access from anywhere |
| Tool Orchestration | Coordinates multiple MCP servers, APIs, and plugins | Unified interface to entire toolchain |
| Self-Learning | Analyzes past interactions to improve future performance | System gets smarter over time |
2.3 Comparison Table
| Dimension | AI Agent | AI Orchestrator |
|---|---|---|
| Scope | Single task | Complex multi-step goal |
| Execution | Sequential | Parallel |
| Memory | Session-limited | Persistent (cross-session) |
| Sub-agents | None | Can spawn and manage |
| Scheduling | None | Built-in cron |
| Platform delivery | Single (usually CLI) | Multi-platform |
| Learning | None | Self-improving via skills |
| Example | Claude Code, OpenCode | Hermes Agent |
3. Hermes Agent — The Orchestrator
3.1 What is Hermes Agent?
Hermes Agent is an open-source (MIT-licensed) AI orchestration platform developed by Nous Research. It is designed as a self-hostable, multi-platform, multi-provider orchestrator that manages the full lifecycle of AI-driven tasks — from goal decomposition through sub-agent delegation to multi-platform delivery.
Unlike coding-focused tools (Claude Code, OpenCode) that operate primarily in the terminal, Hermes is built from the ground up as an enterprise orchestrator:
- Multi-provider: Supports 20+ LLM providers (DeepSeek, OpenAI, Claude, OpenRouter, Groq, local models via vLLM/llama.cpp)
- Multi-platform: Delivers results to Telegram, Discord, Slack, WhatsApp, Signal, email, CLI — simultaneously
- Multi-agent: Spawns isolated sub-agents for parallel task execution
- Persistent memory: Retains context across sessions via MEMORY.md, USER.md, and FTS5 search
- Skills system: Creates reusable procedural knowledge (SKILL.md) automatically
- Cron scheduler: Runs recurring tasks without human intervention
- MCP client: Built-in native support for Model Context Protocol (stdio and SSE transports)
- Self-hosted: Runs locally, via SSH, or in Docker — data never leaves your infrastructure
3.2 Architecture
┌──────────────────────────────────────────────────────────────┐
│ Interface Layer │
│ CLI/TUI │ Telegram │ Discord │ Slack │ WhatsApp │ Signal │
├──────────────────────────────────────────────────────────────┤
│ Gateway Layer │
│ Message routing, authentication, platform abstraction │
├──────────────────────────────────────────────────────────────┤
│ Agent Orchestrator │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ ReAct Loop: │ │
│ │ Reason → Act → Observe → Learn │ │
│ │ Sub-agent spawning (parallel), task decomposition │ │
│ └────────────────────────────────────────────────────────┘ │
├──────────────────────────────────────────────────────────────┤
│ Provider Layer (20+ models) │
│ DeepSeek │ OpenAI │ Claude │ OpenRouter │ Groq │ vLLM │
├──────────────────────────────────────────────────────────────┤
│ Memory & Learning Layer │
│ MEMORY.md │ USER.md │ Skills │ FTS5 │ Session Search │
├──────────────────────────────────────────────────────────────┤
│ Tool & Protocol Layer │
│ MCP (stdio + SSE) │ Plugins │ Cron │ Toolsets │
│ Asana MCP │ Git MCP │ Filesystem │ Terminal │ Web Search │
├──────────────────────────────────────────────────────────────┤
│ Backend Layer │
│ Local │ Docker │ SSH │ Modal │ Daytona │
└──────────────────────────────────────────────────────────────┘
3.3 Key Features in Detail
ReAct Agent Loop
The core execution engine follows the Reasoning + Acting pattern:
1. Reason: Analyze the goal and current context
2. Act: Execute a tool call (terminal, API, file operation)
3. Observe: Read the result
4. Learn: Incorporate findings into the reasoning loop
5. Repeat: Continue until the goal is achieved
Sub-agent Delegation
For complex tasks, Hermes decomposes the goal and spawns isolated sub-agents:
Goal: "Review all microservices for security vulnerabilities"
Sub-agent 1 → Scans MS-AUTH for auth bypass patterns
Sub-agent 2 → Scans MS-API for injection vulnerabilities
Sub-agent 3 → Scans MS-DB for SQL injection points
Sub-agent 4 → Reviews dependency versions for CVEs
All run in parallel → Results synthesized into a single report
Persistent Memory
Hermes maintains three tiers of memory:
- MEMORY.md: Permanent facts about the environment (paths, configs, conventions)
- USER.md: User preferences, communication style, recurring corrections
- Session search: FTS5-powered retrieval across all past conversations
Skills System
Skills are procedural knowledge files (SKILL.md) that encode reusable workflows:
- Trigger conditions (when to use this skill)
- Numbered step-by-step instructions
- Exact commands and code examples
- Common pitfalls and how to avoid them
- Verification steps to confirm success
Skills can be auto-created: when Hermes notices a recurring task pattern, it can save the approach as a skill for future use.
Cron Scheduler
Built-in scheduling for recurring tasks:
Every 30 minutes → Check system health and alert on anomalies
Every 2 hours → Scan logs for error patterns
Daily at 9 AM → Generate and deliver status report
Every Monday → Run compliance audit checklist
Multi-Provider Support
Switch models by task type:
- DeepSeek: Heavy coding and debugging (cost-effective)
- Claude: Code review, architecture analysis (nuanced reasoning)
- GPT-4o: General tasks, content generation
- Local model (vLLM): Sensitive data processing (air-gapped)
3.4 Configuration
Hermes is configured via a single config.yaml file:
# Provider configuration
providers:
anthropic:
api_key: ${ANTHROPIC_API_KEY}
models:
- name: claude-sonnet-4
default: true
openrouter:
api_key: ${OPENROUTER_API_KEY}
models:
- name: deepseek/deepseek-v4
# MCP servers
mcp_servers:
asana:
command: npx
args: ["-y", "@roychri/mcp-server-asana"]
env:
ASANA_ACCESS_TOKEN: ${ASANA_ACCESS_TOKEN}
# Platform connections
platforms:
telegram:
enabled: true
bot_token: ${TELEGRAM_BOT_TOKEN}
discord:
enabled: true
bot_token: ${DISCORD_BOT_TOKEN}
# Skills directory
skills:
path: ~/.hermes/skills/
4. Hermes Gateway — Multi-Platform Access
4.1 Gateway Concept
The Gateway is a single entry point for all interactions with Hermes. Instead of running separate instances for each platform, a single Gateway process handles all connections:
┌─────────┐
│ Telegram │────┐
└─────────┘ │
┌─────────┐ │ ┌──────────────────────┐
│ Discord │────┼────▶ Hermes Gateway │
└─────────┘ │ │ │
│ │ (Central Hub) │────▶ MCP Servers
┌─────────┐ │ │ │────▶ Terminal
│ CLI │────┘ └──────────────────────┘────▶ Cron Jobs
└─────────┘ │
▼
┌─────────┐ ┌──────────┐
│ Email │────┐ │ Memory │
└─────────┘ │ └──────────┘
┌─────────┐ │
│ Slack │────┘
└─────────┘
4.2 Access Scenarios
| Situation | Access Method | Capabilities |
|---|---|---|
| At desk | CLI/TUI | Full power: coding, debugging, file operations |
| In meetings | Telegram/Discord (mobile) | Check status, approve workflows, run reports |
| Commuting | Telegram (mobile) | Monitor systems, quick queries, receive alerts |
| Remote/Home | CLI via SSH or Telegram | Deploy fixes, database queries, review PRs |
| Vacation | Telegram only | Emergency monitoring, critical alerts |
| Anywhere | WhatsApp/Signal | Status updates, simple queries |
4.3 Notification System
The Gateway supports push notifications for important events:
| Event | Delivery Channel | Format |
|---|---|---|
| Build failure | Telegram + Email | ❌ Build failed: [error details] |
| PR ready for review | Team chat | 👀 PR #123 ready for review |
| Task assigned | Personal message | 📋 New task assigned: [title] |
| Daily report | Personal message | 📊 [yesterday's activity summary] |
| Anomaly detected | Team chat + Email | ⚠️ [metric] exceeded threshold |
| Deployment success | Team chat | 🚀 [service] v2.1 deployed to production |
5. MCP Protocol — Tool Integration
5.1 What is MCP?
The Model Context Protocol (MCP) is an open standard developed by Anthropic that provides a universal interface for AI agents to interact with external tools and data sources. It is analogous to USB-C for AI — a single standardized connector for all peripherals.
MCP Architecture:
Host (Hermes Agent)
│
├── MCP Client ──── MCP Server (stdio) ──── Local Tool
│ │ (subprocess)
│ └─── MCP Server (SSE) ──── Remote API
│ (HTTP)
│
└── Lifecycle: Initialize → ListTools → CallTool
Three tiers:
1. Host: The AI application (Hermes Agent)
2. Client: 1:1 connection to a server
3. Server: Provides tools, resources, and prompts
Transports:
- stdio: Local subprocess communication (secure, low latency)
- SSE: Remote server-sent events (HTTP-based, for cloud services)
5.2 Asana MCP — Project & Task Orchestration
The Asana MCP server provides 41 tools for complete task and project lifecycle management. This is Hermes's most powerful integration for workflow automation.
Available Tools by Category
| Category | Tools | Purpose |
|---|---|---|
| Read Tasks | get_task, get_multiple_tasks_by_gid, get_subtasks, get_task_stories |
Fetch task details, descriptions, comments, subtasks |
| Create | create_task, create_subtask, create_project, create_section, create_tag |
Auto-create tasks from external triggers |
| Update | update_task, update_project, update_section |
Change status, priority, due dates |
| Assign | update_task (assignee) |
Auto-assign based on workload or skill |
| Comment | create_task_story |
Post progress updates, link PRs |
| Organize | add_task_to_section, set_parent_for_task |
Move tasks across workflow stages (To Do → In Progress → Review → Done) |
| Dependencies | add_task_dependencies, add_task_dependents |
Chain tasks: dependency must complete before dependent starts |
| Search | search_tasks, search_projects |
Find by custom fields, text, assignee, due dates, tags |
| Tags | add_tag_to_task, remove_tag_from_task, get_tags_for_task |
Categorize by urgency, domain, sprint |
| Projects | get_project, get_project_sections, get_tasks_for_project |
Sprint management, project health overview |
| Workspace | list_workspaces, get_my_tasks |
Cross-project task inventory |
Integration Architecture
┌───────────────────────────────────────────────────────────┐
│ Hermes Agent │
│ │
│ Cron: Every 5min → Check assigned tasks │
│ Cron: Every 1h → Scan for overdue items │
│ Cron: Daily → Generate task completion report │
│ │
│ │ ▲ │
│ ▼ │ │
│ MCP Client (Asana) ────── Asana MCP Server │
│ │ │ │
│ ▼ ▼ │
│ ┌─────────────────────────────────────────────┐ │
│ │ Closed-Loop Workflow Engine │ │
│ │ │ │
│ │ 1. Hermes detects new/updated task │ │
│ │ 2. Reads task details (title, desc, files) │ │
│ │ 3. Spawns sub-agent to analyze requirements │ │
│ │ 4. Sub-agent executes (code, research, etc.) │ │
│ │ 5. Hermes updates Asana: comment + status │ │
│ │ 6. Notifies stakeholders via Telegram/Email │ │
│ └─────────────────────────────────────────────┘ │
└───────────────────────────────────────────────────────────┘
Closed-Loop Task Lifecycle
┌──────────────────────────────────────────────────────────────────────┐
│ Asana → Hermes → Code → PR → Asana │
│ │
│ 1. Task Created in Asana │
│ "Fix autocomplete performance — contoh di form penjualan" │
│ │ │
│ 2. Hermes Detects (via cron or manual `/asana scan`) │
│ │ │
│ 3. Hermes Reads Full Task Context │
│ - Title, description, attachments │
│ - Assignee, priority, due date, custom fields │
│ - Dependencies, project, section │
│ │ │
│ 4. Hermes Executes (sub-agents) │
│ - Read relevant code/files │
│ - Analyze requirements │
│ - Implement solution │
│ - Run tests │
│ │ │
│ 5. Hermes Creates Pull Request │
│ - Branch: feature/dev_{action}-{target}_{author} │
│ - Commit with conventional commit message │
│ - PR with before/after, testing notes │
│ │ ...6. Enterprise Use Cases
6.1 For Manufacturing Companies (e.g., GRC Board Industry)
Manufacturing companies with distributed IT systems can leverage AI orchestration across several domains:
Production Monitoring & Alerting
- Scenario: Real-time dashboards flag anomalies in production line data
- Orchestration: Cron job scans production metrics → detects deviation → retrieves SOP → suggests corrective action → alerts floor supervisor
- Impact: Reduced downtime, faster response to production issues
Quality Control Automation
- Scenario: Defect reports come in from multiple QC checkpoints
- Orchestration: Collects QC data → analyzes defect patterns → cross-references with batch records → creates investigation tasks → assigns to quality team → tracks resolution
- Impact: Systematic quality improvement, audit-ready documentation
Supply Chain Coordination
- Scenario: Raw material inventory drops below threshold
- Orchestration: Detects low inventory → queries supplier lead times → generates purchase requisition → routes for approval → monitors delivery status → updates ERP
- Impact: Just-in-time inventory management, reduced stockouts
Compliance & Audit Readiness
- Scenario: Monthly compliance audit approaching
- Orchestration: Scans document repository → checks all required certifications → identifies gaps → generates checklist → assigns remediation tasks → tracks completion → produces audit-ready report
- Impact: Always-audit-ready posture, reduced manual effort
6.2 For IT and Software Teams
Automated Incident Response
- Monitoring system detects error (e.g., 5xx spike in API gateway)
- Alert routed to Hermes via webhook
- Hermes creates incident task in project management
- Sub-agent analyzes logs, traces, and metrics
- Identifies root cause (e.g., database connection pool exhausted)
- Applies mitigation (e.g., scales connection pool, restarts affected service)
- Creates post-mortem document
- Updates incident task with full timeline
Code Review Automation
- Developer opens PR
- Webhook triggers Hermes review
- Sub-agents run in parallel:
- Security scan (dependency vulnerabilities, hardcoded secrets)
- Code quality (style violations, complexity metrics, test coverage)
- Architecture review (pattern violations, coupling analysis) - Results posted as PR comments
- PR status updated (approve/request changes)
- Author notified via preferred channel
Documentation Generation
- Scan codebase for API endpoints, classes, and interfaces
- Generate OpenAPI/Swagger specs from code
- Create README files for new modules
- Update changelog with recent commits
- Generate architecture decision records (ADRs)
- Push documentation to company wiki or docs site
6.3 For All Enterprises
Daily Operations Briefing
- What: Every morning, deliver a personalized briefing
- Content: Open tasks, scheduled deployments, system health, calendar highlights, relevant news
- Delivery: Telegram/Discord/Slack at configurable time
Knowledge Base Curation
- What: Maintain and enrich a company-wide knowledge base
- Process: Scan existing documents → identify gaps → research and draft new content → cross-reference and link → publish
- Schedule: Recurring enrichment (e.g., every 12 hours)
Automated Reporting
- Sprint reports: Tasks completed, velocity, blockers, burndown
- System health: Uptime, error rates, response times, resource usage
- Compliance: Certification status, pending audits, policy violations
- Business metrics: Sales pipeline, production output, quality metrics
6.4 KPI System Integration (PES)
The PES (Performance Evaluation System) is a KPI management platform used for tracking employee tasks, evaluating performance, and generating departmental reports. This section covers Hermes integration with systems like PES.
PES System Overview
Based on the PES application structure, the system manages:
| Module | Function | Data Fields |
|---|---|---|
| Input Task | Create and assign tasks with KPI weights | TaskNo, Department, PIC, StartDate, TargetDate, FinishDate, Category, Bobot (weight), Uraian Task (description), Goal Task |
| Master PES | Configure KPI master data | Department configurations, scoring rules |
| Recap Modules | Generate period reports | Rekap Task (task summary), Rekap KPI (score summary), Rekap SOP, Rekap PES (full evaluation) |
| Laporan Email | Email-based report delivery | Distribution lists, report formats |
Key data fields per task:
- Bobot: Task weight (determines KPI contribution)
- PointNilai: Scored points upon completion
- Status: T1 (new), T2 (in progress), T3 (completed), etc.
- Asal Task: Source (Inisiatif Individu, Hasil Meeting, Instruksi Atasan, Lain-lain)
- PIC: Person responsible for execution
- Approval: Approving authority
Integration Architecture
┌───────────────────────────────────────────────────────────────┐
│ Hermes Agent │
│ │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ Integration Layer │ │
│ │ │ │
│ │ PES Connector (API/database) │ │
│ │ → Read tasks, KPIs, reports │ │
│ │ → Create/update tasks │ │
│ │ → Update KPI scores │ │
│ │ → Generate reports │ │
│ │ │ │
│ │ Asana ↔ PES Sync Engine │ │
│ │ → Tasks created in Asana → auto-create in PES │ │
│ │ → Tasks completed in Asana → update PES KPI score │ │
│ │ → Status changes sync both directions │ │
│ └────────────────────────────────────────────────────────┘ │
│ │
│ Cron Triggers: │
│ Daily 8 AM → Sync Asana ↔ PES task statuses │
│ Daily 5 PM → Generate daily KPI progress report │
│ Weekly Mon → Generate weekly PES recap │
│ Monthly 1st → Generate monthly KPI evaluation │
│ │
└───────────────────────────────────────────────────────────────┘
Workflow Scenarios
Scenario 1: Auto-Create PES Task from Asana
When a task is created in Asana (e.g., from a sprint planning meeting):
1. Hermes detects new task in Asana (via cron)
2. Reads task details:
- Title: "Implement autocomplete optimization"
- Assignee: MUHAMMAD HERNANDA
- Department: IT
- Due date: 2026-06-15
3. Logs into PES via API/database connector
4. Creates PES task:
- Department: IT
- PIC: MUHAMMAD HERNANDA
- Uraian Task: "Implement autocomplete optimization"
- Bobot: (calculated from task priority/complexity)
- Asal Task: Hasil Meeting
- StartDate: today
- TargetDate: 2026-06-15
5. Posts confirmation to Telegram:
"✅ PES task created: [Implement autocomplete optimization]
📊 Bobot: 15 | Target: 15-Jun-2026"
Scenario 2: Auto-Update KPI Score on Task Completion
When a PR is merged and the Asana task moves to "Done":
1. Hermes detects Asana task moved to "Done"
2. Updates PES task status to T3 (Completed)
3. Sets FinishDate to today
4. Queries PES for PointNilai formula based on:
- Bobot (task weight)
- Timeliness (completed before/after target)
- Quality metrics (from code review score)
5. Calculates and updates PointNilai
6. Adds achievement note to PES record
7. Notifies user:
"🏆 Task completed: [Implement autocomplete optimization]
✅ Status: T3 | Bobot: 15 | Point: 14.5
📈 KPI contribution: +2.3% this period"
Scenario 3: Weekly KPI Recap Automation
1. Every Monday at 8 AM, Hermes triggers recap
2. Queries PES for:
- All tasks completed last week (by department)
- Pending tasks past deadline
- KPI scores by PIC
- Bobot realization percentage
3.7. Comparison: Hermes vs Other Tools
| Feature | Hermes Agent | Claude Code | OpenCode | OpenClaw |
|---|---|---|---|---|
| Open Source | Yes (MIT) | No | Yes (MIT) | Yes (MIT) |
| Self-hostable | Yes (Local/SSH/Docker) | No | Yes | Yes (Node.js gateway) |
| Primary interface | CLI + multi-platform gateway | CLI + IDE | CLI only | Chat gateway + Web UI |
| Multi-provider | 20+ providers | Claude only | Multi | Multi |
| Sub-agent delegation | Yes (parallel) | No | No | Limited (agent routing) |
| Cron scheduler | Yes (built-in) | No | No | No |
| Persistent memory | MEMORY.md, USER.md, FTS5 | CLAUDE.md (basic) | None | Sessions, memory |
| Skills system | Auto-create from workflows | No | No | No |
| MCP support | Full (stdio + SSE) | Full | Partial | Yes |
| API server | Yes (OpenAI-compatible) | No | No | Yes (Gateway API) |
| Cross-session learning | Yes | No | No | No |
| Notifications | Push to any platform | No | No | Via chat channels |
| Mobile access | Via Telegram/Discord/Signal messenger apps | No | No | Via mobile nodes (iOS/Android) |
| Web Control UI | Via connected platforms | No | No | Yes (built-in dashboard) |
| Plugin system | Python-based extensibility | No | No | Channel plugins |
| Language | Python | Node.js/TypeScript | Go | Node.js/TypeScript |
When to Use Each
Choose Hermes Agent when:
- You need enterprise-wide orchestration beyond coding
- You want to access AI from multiple platforms (CLI, mobile chat, email)
- You need scheduled, recurring automation (cron jobs)
- You want a self-hosted solution for data privacy
- You need multi-agent parallel execution
- You want a system that learns and improves over time
Choose Claude Code when:
- You need deep Claude model integration for complex coding tasks
- You prefer Anthropic's ecosystem
- IDE integration is important
- Your workflow is primarily terminal-based
Choose OpenCode when:
- You want a lightweight, fast CLI coding assistant
- You prefer Go-based tooling
- You want multi-model support in a simple package
- Your needs are limited to coding assistance
Choose OpenClaw when:
- You want a self-hosted gateway accessible from any chat platform
- You prefer a Web UI dashboard for managing agents and sessions
- You need mobile node support (iOS/Android) for on-the-go access
- You want a Node.js-based ecosystem with channel plugins
- Your primary use case is personal AI assistant across messaging apps
8. Getting Started
8.1 Quick Installation
# Using pip (recommended)
pip install hermes-agent
# Or using git
git clone https://github.com/nousresearch/hermes-agent.git
cd hermes-agent
pip install -e .
# Verify installation
hermes --version
8.2 Basic Configuration
# Initialize configuration
hermes init
# Set your preferred provider
hermes config set provider anthropic
hermes config set model claude-sonnet-4
# Add an API key
hermes config set anthropic.api_key sk-ant-...
# Start interactive session
hermes
8.3 Key Commands
| Command | Description |
|---|---|
hermes |
Start interactive CLI session |
/new |
Start a fresh conversation |
/resume |
Continue last conversation |
/model |
Switch active model |
/check |
System health status |
/compact |
Compress conversation context |
hermes --serve |
Start API server mode |
8.4 Connecting Platforms
# config.yaml additions
platforms:
telegram:
enabled: true
bot_token: ${TELEGRAM_BOT_TOKEN}
discord:
enabled: true
bot_token: ${DISCORD_BOT_TOKEN}
guild_id: "123456789"
# Then restart Hermes
hermes --serve
9. Roadmap and Evolution
9.1 Current Capabilities (2026)
- ✅ Multi-platform gateway (Telegram, Discord, CLI, Signal, Email)
- ✅ Multi-provider support (20+ LLM providers)
- ✅ MCP client (stdio + SSE transports)
- ✅ Sub-agent delegation (parallel execution)
- ✅ Persistent memory (MEMORY.md, USER.md, FTS5)
- ✅ Skills system (auto-create from workflows)
- ✅ Cron scheduler (recurring tasks)
- ✅ Plugin system (Python-based extensibility)
- ✅ API server (OpenAI-compatible endpoint)
9.2 Near-Term Development
| Feature | Timeline | Impact |
|---|---|---|
| Visual workflow builder | Q3 2026 | Drag-and-drop agent workflow design |
| Enhanced multi-agent coordination | Q3 2026 | Better inter-agent communication patterns |
| Knowledge graph integration | Q4 2026 | Structured company knowledge representation |
| Advanced RAG pipeline | Q4 2026 | Enterprise-grade retrieval with hybrid search |
| Team collaboration features | Q4 2026 | Multi-user sessions, shared contexts |
9.3 Long-Term Vision
- Autonomous AI teams: Self-organizing groups of specialized agents
- Cross-enterprise orchestration: Secure inter-company agent communication
- Agent marketplaces: Pre-built specialized agents for common enterprise functions
- Self-improving infrastructure: AI that proactively identifies and resolves infrastructure issues
- Natural language business intelligence: Ask questions about any business metric in natural language
AI Library of Alexandria — Hermes · 1 Docs · 994 Lines
Home · June 2026