Hermes Agent Complete Command Cheat Sheet — Print It, Stick It on Your Wall

Abstract: The Hermes Agent command system consists of 4 layers: Top-level CLI (38 commands), Global Options, Session Slash commands, and Dynamic Slash (skill invocation). This article organizes all commands into quick-reference tables, grouped by scenario, with practical usage tips and caveats. Print it out and keep it handy.

Can't memorize them all? Just stick this on your wall.

Command System Overview: 4-Layer Architecture

Understanding Hermes's command system starts with grasping its 4 layers:

Layer	Entry Point	Purpose	Typical Examples
Top-level CLI	`hermes <command>`	Configuration, operations, lifecycle management	`hermes setup`, `hermes gateway start`
Global Options	`hermes [options]`	Global switches	`--profile`, `--worktree`, `--yolo`
Session Slash	`/<command>`	In-session actions, display control	`/model`, `/compress`, `/usage`
Dynamic Slash	`/<skill-name>`	Invoke installed Skills	`/github-pr-workflow`

CLI vs Slash — The Key Difference: CLI commands run in the terminal and can add new providers, run OAuth flows, and register API Keys; Slash commands are used within sessions to control the current conversation behavior. Simply put: CLI manages "the Hermes tool itself," while Slash manages "this particular conversation."

A Common Point of Confusion: hermes model and /model are not the same thing. The former is a CLI command that can add new providers, run OAuth, and register API Keys; the latter is a Slash command that only switches models within the current session without affecting global configuration. If you find that your model switch reverts after restart, you probably used the Slash /model instead of the CLI hermes model.

Understanding the Four-Layer Relationship: Think of it this way — CLI commands are like the settings menu of an application (affect the tool itself), Global Options are like launch parameters (configure how the tool starts), Session Slash commands are like in-app shortcuts (control the current session), and Dynamic Slash is like plugin commands (extend functionality). This mental model helps you quickly determine which layer's command you need.

When to Use Which Layer: - Need to install something or change system-level config? → CLI - Need to customize how Hermes starts? → Global Options - Need to change something in the current conversation? → Slash - Need to use a specific workflow? → Dynamic Slash (skills)

This distinction might seem subtle at first, but it becomes second nature after a few days of use. The key insight: if you want the change to persist across sessions, use CLI. If you only need it for this session, use Slash.

文章配图

I. Top-level CLI Commands (38, Grouped by Scenario)

1.1 Startup & Conversation (5 commands)

Command	Purpose	Notes
`hermes`	Start interactive CLI	Most commonly used
`hermes chat`	Same as above, explicit form	Equivalent to `hermes`
`hermes chat -q "question"`	One-shot non-interactive mode	Preserves banner, tool preview
`hermes -z "question"`	Clean one-shot mode	Returns only final answer text, ideal for cron/CI/scripts
`hermes --tui`	Launch modern TUI interface	Recommended for better experience

Practical Usage: Use hermes -z for scripted scenarios, hermes --tui for interactive development. The -z mode outputs only plain text to stdout, making it easy to pipe to other tools.

Deep Dive on hermes -z: This is the Swiss Army knife for automation. The -z flag (short for "zero-frills") strips away all interactive elements — no banner, no tool previews, no progress indicators. Just the final answer, clean and pure. This makes it perfect for: - Cron jobs: 0 8 * * * hermes -z "Generate daily report" >> /var/log/hermes-daily.log - CI/CD pipelines: hermes -z "Review this PR for security issues" < pr-diff.txt - Shell scripts: result=$(hermes -z "Summarize this log file" < app.log)

Deep Dive on hermes --tui: The TUI (Terminal User Interface) mode provides a much richer experience than the classic CLI. It supports: - Real-time streaming of Agent responses - Syntax highlighting for code blocks - Tool execution visualization - Session management sidebar - Keyboard shortcuts for common actions

If your terminal supports it (most modern terminals do), always prefer --tui over the classic mode. The experience difference is like night and day.

1.2 Configuration & Diagnostics (6 commands)

Command	Purpose	Notes
`hermes setup`	Interactive complete setup wizard	Must run on first use
`hermes model`	Configure/switch LLM provider and model	Recommended for first run
`hermes doctor`	Diagnose configuration and dependency issues	Run this first when problems arise
`hermes status`	View Agent, authentication, platform status	See everything at a glance
`hermes config`	View/edit configuration files	Advanced usage
`hermes update`	Update Hermes to latest version	Update regularly

Pitfall Warning: hermes doctor can detect 80% of common problems, including wrong Python versions, expired API Keys, and network issues. When something goes wrong, run this first — it's 10x faster than manual troubleshooting.

An Overlooked Command: hermes status gives you an at-a-glance view of all platform connection states — whether the Agent is online, which platform authentications are about to expire, and whether Gateways are running normally. My personal habit is to run hermes status every morning to confirm everything is working before starting work.

The hermes config Command — Power User's Best Friend: While hermes setup is great for initial configuration, hermes config is where you fine-tune everything. It supports: - Viewing current configuration: hermes config show - Editing specific values: hermes config set <key> <value> - Resetting to defaults: hermes config reset - Exporting configuration: hermes config export > backup.json

Configuration is stored in ~/.hermes/config.json by default, but you can override this with the HERMES_CONFIG_DIR environment variable. This is useful when you want different configurations for different machines or environments.

hermes update — Keep It Fresh: Hermes is evolving rapidly, with new features and bug fixes shipping weekly. Running hermes update regularly ensures you're always on the latest version. The update process is non-destructive — it preserves your configuration, skills, and memory files. If something goes wrong after an update, you can always rollback with hermes update --rollback.

1.3 Authentication Management (4 commands)

Command	Purpose	Notes
`hermes auth`	Manage credentials (add/list/delete/reset/policy)	Unified entry point
`hermes login`	Deprecated	Use `hermes auth` instead
`hermes logout`	Deprecated	Use `hermes auth` instead
`hermes auth add <provider>`	Add new provider authentication	Supports OAuth flow

Supported Authentication Providers: Hermes supports a wide range of LLM providers through its authentication system: - OpenAI: API Key authentication (hermes auth add openai) - Anthropic: API Key authentication (hermes auth add anthropic) - DeepSeek: API Key authentication (hermes auth add deepseek) - Google Gemini: API Key authentication (hermes auth add google) - Local Models: Via Ollama or LM Studio (hermes auth add local) - Custom OpenAI-compatible: Any provider with an OpenAI-compatible API

Authentication Policies: hermes auth also supports setting policies for credential management: - Auto-rotation: Automatically refresh tokens before they expire - Scope restriction: Limit which tools each authenticated provider can use - Budget capping: Set spending limits per provider to prevent unexpected charges

Multi-Provider Setup: One of Hermes's most powerful features is the ability to use different providers for different tasks. For example, you can configure DeepSeek for routine conversations (cheap), Claude for complex reasoning (expensive but capable), and a local model for sensitive data (private). The hermes model and /model commands let you switch between these seamlessly.

1.4 Gateway Management (5 commands)

Command	Purpose	Notes
`hermes gateway start`	Start messaging gateway service	For Telegram/Discord etc.
`hermes gateway stop`	Stop gateway	—
`hermes gateway status`	View gateway status	Confirm connection is normal
`hermes gateway restart`	Restart gateway	Needed after config changes
`hermes gateway logs`	View gateway logs	Essential for troubleshooting

Practical Usage: When configuring a Telegram Bot, first run hermes gateway start, then bind the Token. If the Bot doesn't respond, check hermes gateway logs — 90% of the time it's a network timeout or expired Token.

Gateway Architecture: Understanding how the gateway works helps with troubleshooting: 1. The gateway runs as a background daemon process 2. It maintains persistent connections to messaging platforms 3. When a message arrives, it creates a new Hermes session (or resumes an existing one) 4. The Agent processes the message and sends the response back through the gateway 5. Multiple platforms can share the same gateway instance

Gateway Performance Tuning: If you experience slow response times on messaging platforms: - Increase the gateway's maximum concurrent sessions: hermes config set gateway.maxSessions 10 - Enable response streaming: hermes config set gateway.streaming true - Use Webhook mode instead of long polling (requires a public URL) - Consider running the gateway on a machine with lower latency to the messaging platform's servers

Gateway Security: The gateway implements several security measures: - Rate limiting per platform and per user - Tool permission enforcement per platform - Input sanitization to prevent prompt injection via messaging platforms - Session isolation between different users on shared platforms

These security features are especially important on platforms like Discord where multiple users might interact with the same bot.

1.5 WhatsApp Bridge (3 commands)

Command	Purpose	Notes
`hermes whatsapp`	Configure and pair WhatsApp bridge	Requires QR code scan
`hermes whatsapp status`	View WhatsApp connection status	—
`hermes whatsapp reset`	Reset WhatsApp connection	Use when connection is abnormal

WhatsApp Bridge Notes: Unlike Telegram and Discord which use Bot APIs, WhatsApp integration uses the WhatsApp Web bridge. This means you need to scan a QR code with your phone to authorize the connection. The bridge maintains a persistent session, so you only need to scan once. However, if your phone loses connection or the session expires, you'll need to re-scan. Use hermes whatsapp status to check if the bridge is still active, and hermes whatsapp reset if it's not responding.

1.6 Skills & Tools (5 commands)

Command	Purpose	Notes
`hermes skills`	List/manage installed skills	View skill library
`hermes skills add <url>`	Install skill from URL	Community skill installation
`hermes skills remove <name>`	Uninstall skill	—
`hermes tools`	View/manage toolsets	20+ tools, enable as needed
`hermes tools enable <tool>`	Enable specified tool	Fine-grained permission control

Key Toolsets: terminal (core of cores — execute Shell commands), file (read/write/search/edit files), web/browser (web search and browser automation), memory (cross-session persistent memory), skills (skill management and auto-loading), delegation (sub-agent task delegation), cronjob (scheduled task scheduling), session_search (review historical sessions).

Each toolset can be independently enabled/disabled per platform. This is particularly important on messaging platforms like Telegram/Discord — for example, you might not want to enable terminal on Telegram (to avoid accidental operations), but it's the most core tool in the CLI.

1.7 Other Commands (10 commands)

Command	Purpose
`hermes history`	View historical session list
`hermes session <id>`	Resume specified session
`hermes export <id>`	Export session records
`hermes mcp`	MCP server management
`hermes sandbox`	Sandbox environment management
`hermes version` / `-V`	View version
`hermes help`	Help information
`hermes rl`	RL training trajectory export
`hermes profile`	Manage multiple configuration profiles
`hermes worktree`	Git worktree management

hermes export — Documentation and Compliance: This command exports session records in multiple formats (JSON, Markdown, HTML). It's useful for creating documentation from Agent-assisted coding sessions, compliance record-keeping in regulated industries, sharing knowledge with team members, or creating training data. Usage: hermes export <session-id> --format markdown --output session-notes.md

hermes mcp — Model Context Protocol: The MCP integration allows Hermes to connect with external tool servers, extending capabilities beyond the built-in toolset. For example, connect to a database MCP server for direct SQL queries, or a Jira MCP server for project management. Setup: hermes mcp add <server-name> <server-url>.

hermes sandbox — Safe Execution Environment: Manages isolated execution environments for running untrusted code. The sandbox uses container-based isolation (Docker/Podman) to ensure code running inside cannot affect the host system — critical when processing user-uploaded files or running Agent-generated code that hasn't been reviewed yet.

hermes rl — Reinforcement Learning Export: A unique feature that exports RL training trajectories from your Hermes sessions. This data can be used to fine-tune models on your specific usage patterns, creating a personalized Agent that better understands your workflows over time.

II. Global Options

Option	Shorthand	Purpose	Typical Scenario
`--profile <name>`	`-p`	Specify configuration profile	Multi-instance isolation
`--resume <session>`	`-r`	Resume specified session	Continue previous work
`--continue [name]`	`-c`	Resume most recent session	Quick recovery
`--worktree`	`-w`	Use isolated git worktree	Parallel agent workflows
`--yolo`	—	Skip dangerous command confirmation	⚠️ Use with extreme caution! Only in trusted environments
`--tui`	—	Force TUI interface	Preference for modern UI
`--quiet`	`-Q`	Quiet mode	Scripts/CI environments
`--pass-session-id`	—	Include session ID in system prompt	Debugging
`--dev`	—	Run TS source directly via tsx	For TUI contributors

⚠️ Warning about --yolo: This option skips all approval confirmations for dangerous commands, meaning Hermes can execute destructive operations like rm -rf without your consent. Only use in fully trusted environments (e.g., inside containers). Absolutely never enable in production environments.

A Real --yolo Horror Story: A community user enabled --yolo on their main development machine and asked Hermes to "clean up the project directory." Hermes interpreted this as removing all .log and .tmp files, but also deleted several important configuration files that happened to match the pattern. The lesson: --yolo removes the safety net. If you must use it, at least pair it with --worktree to isolate the working directory.

Other Global Options Worth Knowing: - --pass-session-id: Injects the current session ID into the Agent's system prompt. Useful for debugging and for tools that need to track which session made a request. - --dev: Runs the TUI directly from TypeScript source code using tsx. Only useful if you're contributing to the TUI codebase. Regular users can ignore this. - --quiet / -Q: Suppresses all non-essential output. Different from -z in that it still supports interactive mode but with minimal logging. Good for when you want a clean terminal experience without going full non-interactive.

III. Session Slash Commands (Use Within Conversations)

3.1 Model & Configuration (4 commands)

Command	Purpose	Notes
`/model`	Switch model within session	Doesn't affect global configuration
`/model <name>`	Switch directly to specified model	Shortcut
`/config`	View current configuration	—
`/profile`	Switch configuration profile	—

3.2 Session Control (6 commands)

Command	Purpose	Notes
`/compress`	Compress current context	Use when context is too long
`/clear`	Clear current session	Start fresh
`/usage`	View token usage	Essential for tracking costs
`/cost`	View current session cost	Budget control
`/session`	View session information	—
`/save`	Save current session	Prevent data loss

Understanding /compress: This is one of the most important Slash commands. When your conversation grows beyond the model's context window, Hermes needs to compress the history to continue. The compression process: 1. Identifies the most important information in the conversation 2. Creates a summary of earlier exchanges 3. Replaces detailed history with condensed summaries 4. Preserves recent exchanges in full detail

The trade-off: compression reduces token usage but may lose nuanced details. If you're in the middle of a complex debugging session, consider using /save first, then /compress. This way, you can always refer back to the full conversation if needed.

/usage and /cost — Budget Management: These two commands are essential for anyone paying for API usage. /usage shows raw token counts (input tokens, output tokens, tool call tokens), while /cost translates those into dollar amounts based on your configured model's pricing. Pro tip: check /cost before and after complex operations to understand the cost implications of different tasks. Code generation and multi-tool workflows tend to be the most expensive.

3.3 Memory & Skills (4 commands)

Command	Purpose	Notes
`/memory`	View current memory state	Three-layer memory overview
`/memory search <query>`	Search historical memory	Find previous content
`/skills`	List available skills	View within session
`/skill <name>`	Load specified skill	Quick invocation

/memory search — Your Second Brain: This command searches across all three memory layers (working, long-term, and reflective). It's particularly useful when: - You discussed something yesterday but can't remember the details - You worked on a similar problem before and want to recall the solution - You need to find a decision you made in a previous session

The search uses semantic matching, not just keyword matching, so you can describe what you're looking for in natural language. For example, /memory search "how we fixed the database timeout issue" will find relevant conversations even if the exact words don't match.

Memory Management Tips: - Periodically review /memory to see what Hermes has stored about you - If memory retrieval is returning irrelevant results, manually edit memory files in ~/.hermes/memory/ - Use clear, distinctive project names in conversations to help Hermes disambiguate contexts - Consider creating a "project brief" skill that you load at the start of each project session — this gives Hermes immediate context

3.4 Tools & Gateway (4 commands)

Command	Purpose	Notes
`/tools`	View enabled tools	—
`/tools enable <name>`	Enable tool within session	—
`/tools disable <name>`	Disable tool within session	Security control
`/gateway`	View gateway status	—

3.5 Other (3 commands)

Command	Purpose
`/help`	View help
`/exit` / `/quit`	Exit session
`/feedback <text>`	Submit feedback

IV. Dynamic Slash (Skill Dynamic Invocation)

Format: /<skill-name> [arguments]

Examples: - /github-pr-workflow — Invoke GitHub PR workflow skill - /deploy-prod — Invoke production deployment skill - /daily-report — Invoke daily report generation skill

Skill names come from your skill library — whatever skills you have installed determines what commands are available. Use hermes skills or /skills to view the complete list.

Skill Naming Convention Recommendation: Use lowercase + hyphens, such as github-pr-workflow, deploy-prod, daily-report. Avoid spaces and special characters, as they may cause parsing errors during Slash invocation.

Two Ways to Create Skills: First, automatic creation by Hermes — when you complete a complex workflow (calling tools 5+ times), it automatically generates a skill file; second, manual creation — writing Markdown directly in the skills directory. Both approaches have advantages: automatic creation saves time but may not be precise enough; manual creation is precise but time-consuming. The recommendation is to start with automatic creation, then manually fine-tune.

Skill File Anatomy: Understanding the structure of skill files helps you create better ones. A typical Hermes skill file contains:

---
name: github-pr-workflow
description: Create and manage GitHub pull requests
triggers: ["create PR", "pull request", "PR"]
tools: [terminal, file, web]
---
# GitHub PR Workflow

## Steps
1. Check current branch status
2. Ensure tests pass
3. Push to remote
4. Create PR via GitHub CLI
5. Add reviewers and labels

The frontmatter (between --- markers) contains metadata that Hermes uses for skill discovery and invocation. The body contains the actual workflow instructions. When you create skills manually, following this structure ensures Hermes can properly index and invoke them.

Community Skills Ecosystem: Hermes has a growing community skill repository at skills.hermes-agent.dev (unofficial). Popular community skills include: - docker-compose-deploy: Deploy applications using Docker Compose - aws-infra-audit: Audit AWS infrastructure for security issues - seo-content-writer: Generate SEO-optimized content - data-pipeline-builder: Build data processing pipelines

To install a community skill: hermes skills add https://skills.hermes-agent.dev/docker-compose-deploy

Skill Versioning Best Practice: Skills evolve over time. When you update a skill that others might depend on, consider creating a new version rather than modifying the existing one. This way, workflows that depend on the old behavior continue to work. A simple approach is to append a version number to the skill name: deploy-prod-v1, deploy-prod-v2, etc.

V. Practical Scenario Quick Reference

The following 7 scenarios cover 90% of daily Hermes usage needs. Each scenario has been tested and verified — just copy and paste.

Scenario 1: First-time Installation & Configuration

hermes setup          # Interactive setup wizard
hermes model          # Select LLM provider and model
hermes doctor         # Confirm everything is normal
hermes --tui          # Launch TUI and start using

Scenario 2: Configuring Telegram Bot

hermes auth add telegram    # Add Telegram authentication
hermes gateway start        # Start gateway
hermes gateway status       # Confirm connection
hermes gateway logs         # Check logs for troubleshooting

Detailed Telegram Setup Walkthrough: The Telegram integration is one of Hermes's most popular features. Here's the complete setup process:

Create a Telegram Bot: Message @BotFather on Telegram, send /newbot, follow the prompts to get your Bot Token.
Add Authentication: Run hermes auth add telegram, paste the Bot Token when prompted.
Start the Gateway: hermes gateway start — this creates a long-running process that connects to Telegram's API.
Test: Send a message to your bot on Telegram. If everything is configured correctly, Hermes will respond.
Make it Persistent: Add hermes gateway start --daemon to your system's startup scripts so it automatically starts on boot.

Common Telegram Issues: - Bot doesn't respond → Check hermes gateway logs for connection errors - Responses are slow → Switch from long polling to Webhook mode (requires a public URL) - Bot sends duplicate messages → Usually a gateway restart issue; hermes gateway restart fixes it - Bot can't access tools → Check tool permissions for the Telegram platform in hermes config

Scenario 3: Scripted Batch Tasks

hermes -z "Check all PR statuses and generate summary" > report.txt
# Pure text output, suitable for cron scheduled invocation

Advanced Scripting Patterns: The -z mode opens up a world of automation possibilities. Here are some patterns I use regularly:

Daily Standup Generator:

#!/bin/bash
# Save as /usr/local/bin/daily-standup
hermes -z "Review yesterday's git commits and generate a standup summary with: what was done, what's planned today, any blockers" >> ~/standup-$(date +%Y%m%d).txt

Code Review Automation:

#!/bin/bash
# Save as /usr/local/bin/auto-review
diff_file=$1
hermes -z "Review this code diff for: security issues, performance problems, code style violations, and suggest improvements" < "$diff_file"

Log Anomaly Detection:

#!/bin/bash
# Save as /usr/local/bin/log-check
hermes -z "Analyze this server log for anomalies, errors, and patterns that need attention. Prioritize by severity." < /var/log/app.log | mail -s "Log Analysis Report" [email protected]

Integration with KaiheAiBox A1: On A1, these scripts run via cron without any manual intervention. The device's always-on nature means your automation truly runs 24/7, not just when your laptop is open.

Scenario 4: Parallel Workflows

hermes -w -p project-a chat   # Window 1: Project A
hermes -w -p project-b chat   # Window 2: Project B
# Worktree isolation, no interference

Understanding --worktree: This flag creates an isolated Git worktree for each Hermes session. This means: - Each session has its own working directory - Changes in one session don't affect another - You can have multiple Agents working on different branches simultaneously - When the session ends, the worktree is automatically cleaned up

This is invaluable for scenarios like: - Working on a feature branch while also doing a hotfix on main - Running multiple code reviews in parallel - Having one Agent do research while another writes code

--profile for Multi-Environment Management: Profiles let you maintain completely separate Hermes configurations. Each profile has its own: - Model preferences - API Keys - Tool permissions - Memory database - Skill library

This is perfect for separating work and personal projects, or for managing different clients' environments on the same machine.

Scenario 5: Model Switching for Cost Savings

/model deepseek-chat         # Use cheap model for daily tasks
/model claude-sonnet         # Switch to powerful model for complex reasoning
# Switch anytime within session, doesn't affect global config

Cost Optimization Strategy: A practical approach is to use cheaper models (like DeepSeek Chat at ~$0.14/M tokens) for routine tasks — code formatting, simple questions, text editing — and switch to premium models (like Claude Sonnet at ~$3/M tokens) only for complex reasoning, architecture design, or debugging difficult issues. Over a month, this strategy can reduce API costs by 60-80% without sacrificing quality where it matters. Many experienced Hermes users report spending less than $20/month with this approach, compared to $100+ if they used premium models exclusively.

Scenario 6: Memory Search for Previous Content

/memory search "database optimization"   # Search historical memory
# Find previously discussed related content, auto-load context

Scenario 7: Check Costs to Avoid Overspending

/usage                        # View token usage
/cost                         # View current session cost
# Check regularly (daily/weekly) to control API expenses

VI. Using with KaiheAiBox A1: 7×24 Command-Line Assistant

The Hermes Agent command system is naturally suited for 7×24 always-on agent computers like KaiheAiBox A1.

hermes -z mode + cron = Scheduled Task Engine. Set up crontab on KaiheAiBox A1, running hermes -z "Generate yesterday's work summary" every morning at 8 AM, with plain text output to a file. When you wake up, the summary is ready. No need to turn on your computer, no manual triggering — A1 is always running.

hermes gateway + Telegram = Mobile Command Center. Run gateway on A1, and use your phone's Telegram to @HermesBot for instructions anytime. While in a meeting, have the Agent check materials, modify code, and send notifications — everything's done when you return.

--worktree + --profile = Multi-task Parallelism. A1's low-power ARM architecture is suitable for running multiple lightweight Agent instances. Use different profiles to isolate different projects, and worktree ensures no code conflicts. One A1 serving 3-5 parallel tasks simultaneously is no problem.

Operational Recommendation: KaiheAiBox A1's default configuration should be — auto-start gateway (Telegram/Discord) + cron scheduled tasks + one persistent CLI session. SSH in and run hermes --tui to immediately enter working state. No reconfiguration needed each time — the memory system automatically restores context.

Advanced Trick: Use --profile to create multiple configuration profiles on A1. For example, one profile for "development" (enabling terminal + file + web), and another for "monitoring" (only enabling cronjob + memory). Use systemd to manage multiple instances — one A1 simultaneously serving different purposes, maximizing efficiency.

Why This Matters: The biggest advantage of running Hermes on a dedicated always-on device isn't just convenience — it's continuity. Hermes's three-layer memory system becomes exponentially more valuable when the Agent is always running. Every scheduled task, every conversation, every skill created — it all feeds back into the memory system. An always-on Hermes Agent literally gets smarter every day, because it's constantly accumulating experience without interruption.

This is why KaiheAiBox's positioning as an "Agent Computer" rather than just a mini PC makes so much sense. It's not about the hardware specs — it's about providing a stable, always-available runtime environment for Agent workloads. And Hermes Agent, with its emphasis on persistent memory and skill accumulation, is arguably the perfect software match for this hardware concept.

Cost Analysis: Running Hermes on A1 consumes about 5-8 watts (ARM architecture, no display). That's roughly 120-192 watt-hours per day, or about 4-6 kWh per month. At average electricity rates, this costs less than $1/month. Compare this to running your main PC 24/7 (300-500 watts = $30-50/month in electricity), and the economics are compelling. Plus, you get the isolation benefit — Hermes on A1 can't accidentally mess with your main machine's files.

VII. Important Notes

Use --yolo with extreme caution: It skips all safety confirmations. Only use in isolated environments like containers.
hermes -z doesn't preserve context: Each invocation is a fresh session. Use -r to resume if you need context.
/compress loses detail: After compression, information is reduced. Use /save first for important content.
hermes doctor is the first troubleshooting tool: It can diagnose 80% of problems.
Follow skill naming conventions: Use lowercase + hyphens (e.g., github-pr-workflow), avoid special characters.
Gateway logs are troubleshooting gold: If Telegram/Discord doesn't respond, check gateway logs first.
hermes -z paired with cron is the best combo: Scheduled tasks output plain text, easy for downstream processing.
Use /compress and /save together: Save before compressing to prevent important information loss.
Skill files can be manually edited: Skills are stored as local Markdown files — if they're not perfect, just edit them directly.
Use hermes history to find old sessions: Forgot which session discussed a particular topic? Use history to browse records.

VIII. Keyboard Shortcuts for TUI Mode

When using hermes --tui, several keyboard shortcuts speed up your workflow:

Shortcut	Action
`Ctrl+C`	Cancel current Agent response
`Ctrl+D`	Exit session
`Ctrl+L`	Clear screen
`Ctrl+R`	Reverse search history
`↑` / `↓`	Navigate input history
`Tab`	Auto-complete commands and file paths
`Escape`	Cancel current input
`Ctrl+K`	Cut text from cursor to end of line
`Ctrl+U`	Cut text from start of line to cursor
`Ctrl+W`	Delete word before cursor

These shortcuts follow standard terminal conventions, so if you're comfortable with bash/zsh, you'll feel right at home.

IX. Common Error Messages and Solutions

Error	Cause	Solution
`Model not found`	Invalid model name or provider not configured	Run `hermes model` to reconfigure
`Auth token expired`	API Key or OAuth token expired	Run `hermes auth add <provider>`
`Gateway connection failed`	Network issue or service down	Check `hermes gateway logs`
`Context window exceeded`	Conversation too long	Use `/compress` to reduce context
`Tool not available`	Tool not enabled for current platform	Use `hermes tools enable <tool>`
`Skill not found`	Skill name doesn't match installed skills	Check `/skills` for available skills
`Rate limit exceeded`	Too many API calls	Wait and retry, or switch to a different model
`Memory retrieval failed`	Corrupted memory database	Run `hermes doctor` to diagnose

X. Summary: The 10 Most Important Commands

If you only remember 10 commands, make it these:

hermes — Start using Hermes
hermes setup — First-time configuration
hermes model — Choose your AI model
hermes doctor — Fix problems
hermes -z "question" — Script-friendly one-shot mode
/model <name> — Quick model switch in session
/compress — Manage long conversations
/memory search <query> — Find what you discussed before
/usage — Track your costs
hermes gateway start — Connect to Telegram/Discord

Master these 10 and you've covered 80% of daily usage. Come back to this cheat sheet for everything else.

Final Advice: Don't try to memorize all 38 CLI commands. Instead, bookmark this article, print it out, or keep it open in a browser tab. The commands you use most frequently will naturally stick in your memory. The rest you can look up as needed. That's the whole point of a cheat sheet — it's there when you need it, so you don't have to carry it all in your head.

Hermes Agent is designed to learn and adapt to your workflow over time. The more you use it, the more it understands your patterns and preferences. Combined with the right hardware (like KaiheAiBox A1 for always-on operation), it becomes not just a tool, but a reliable digital companion that genuinely makes your work easier every single day.

KaiheAiBox · Hermes Zone

Every Hermes Agent Command in One Cheat Sheet: Print It and Stick It on Your Wall