hermes-agent

Hermes abstracts LLM provider selection through a runtime resolution system that supports OpenAI-compatible endpoints, Anthropic, and local models. The architecture uses a provider registry pattern where model metadata (context windows, capabilities, pricing) is resolved at runtime, enabling fallback chains and dynamic provider switching without code changes. This decouples agent logic from specific LLM implementations, allowing users to swap providers via configuration or environment variables.

Hermes implements persistent memory through Honcho, a memory management system that stores conversation history, context, and agent-learned patterns across sessions. The architecture maintains a session-based memory store where each conversation thread has associated metadata, allowing the agent to retrieve relevant historical context and build on previous interactions. Memory is indexed and queryable, enabling the agent to surface relevant past interactions during decision-making without exceeding context windows.

Hermes supports scheduling agent tasks to run on a cron schedule or at specific intervals, enabling autonomous agents to perform periodic work (data collection, report generation, monitoring, etc.). The architecture uses a scheduler that manages task timing, handles missed executions, and logs task history. Scheduled tasks can access the full agent capabilities (tools, memory, subagents) and are executed in the same environment as interactive agent sessions.

Hermes supports voice interaction through speech-to-text transcription and text-to-speech synthesis, enabling agents to communicate via voice. The architecture integrates transcription services (Whisper, etc.) to convert user speech to text for agent processing, and TTS services to convert agent responses back to speech. Voice mode works across all deployment interfaces (CLI, messaging platforms) and maintains conversation context across voice turns.

Hermes includes a batch processing system that can run agents against large datasets, generating trajectories (sequences of agent actions and outcomes) for reinforcement learning training. The architecture supports parallel batch execution, result aggregation, and trajectory formatting for RL frameworks. Batch jobs can be configured with different agent configurations, toolsets, and model parameters to generate diverse training data.

Hermes implements the Agent Client Protocol (ACP) server, enabling integration with IDEs and code editors (VS Code, etc.) as a native extension. The ACP server exposes agent capabilities through a standardized protocol, allowing IDEs to invoke agent tools, request code generation, and display results inline. This enables developers to use Hermes agents directly within their development environment without context switching.

Hermes provides an interactive command-line interface (CLI) with a terminal user interface (TUI) dashboard that displays agent status, conversation history, tool execution, and memory state in real-time. The TUI uses keyboard navigation and mouse support for interactive control, and the CLI supports slash commands for agent control (e.g., `/clear` to reset memory, `/tools` to list available tools). The dashboard updates in real-time as the agent executes, providing visibility into agent behavior.

Hermes includes a web-based dashboard UI that provides a browser-based interface for agent interaction, session management, and monitoring. The dashboard displays conversation history, agent status, memory state, and tool execution logs. Users can create multiple sessions, switch between them, and manage agent configurations through the web interface. The dashboard connects to the agent backend via WebSocket or HTTP API for real-time updates.

Hermes allows agents to create and register new skills (reusable tool functions) dynamically during execution, with a skills management system that validates, stores, and distributes skills across agent instances. The architecture includes a Skills Hub where agents can publish skills, and a security layer that requires explicit approval for skill execution. Skills are versioned and can be distributed as toolset packages, enabling agents to extend their own capabilities and share learned behaviors with other agents.

Hermes provides a messaging gateway architecture that abstracts the agent core from multiple user-facing interfaces (CLI, Telegram, Discord, WhatsApp, DingTalk, etc.) through platform adapters. The gateway handles session management, media handling, and platform-specific protocol translation, allowing a single agent instance to serve multiple messaging platforms simultaneously. Each platform adapter implements a standardized interface for message routing, user authentication, and response formatting.

Hermes implements a tool registry system where tools are registered with JSON schemas that describe parameters, return types, and execution constraints. The registry uses schema-based function calling to enable the LLM to invoke tools with type-safe arguments, supporting native function-calling APIs from OpenAI and Anthropic. Tools are organized into toolsets that can be selectively enabled/disabled per agent instance, and the registry validates tool invocations against their schemas before execution.

Hermes provides tools for terminal command execution and file operations (read, write, delete, search) with a command approval system that requires explicit user consent before executing potentially dangerous operations. The architecture includes a security layer that parses commands, identifies risky operations (e.g., `rm -rf /`), and presents them to the user for approval. File operations are sandboxed to a configurable working directory, and command execution can be restricted to specific shells or command patterns.

Hermes integrates the Model Context Protocol (MCP) for standardized tool communication and supports direct code execution (Python, JavaScript, shell) within sandboxed environments. The architecture allows agents to execute code snippets, interact with MCP-compliant tools, and receive structured results. Code execution is isolated from the main agent process, and MCP tools are registered in the tool registry alongside native Hermes tools, providing a unified interface for tool invocation.

Hermes supports spawning subagents that can be delegated specific tasks, enabling hierarchical task decomposition where complex problems are broken into subtasks handled by specialized agents. The architecture allows the main agent to create subagents with specific toolsets, memory contexts, and model configurations, then coordinate their execution and aggregate results. Subagents can themselves spawn further subagents, creating multi-level hierarchies for complex problem-solving.

Hermes abstracts execution environments through a pluggable backend system that supports local execution, containerized execution (Docker), and cloud execution (AWS Lambda, etc.). The architecture defines a standard execution interface that all backends implement, allowing agents to execute code/commands in different environments without code changes. Environment selection is configurable per agent instance, and the system handles environment-specific setup (container image selection, cloud credentials, etc.).

Hermes implements context compression techniques to manage token usage and stay within LLM context windows, especially important for long-running agents with extensive conversation history. The system uses summarization, relevance filtering, and hierarchical compression to reduce context size while preserving critical information. Compression is applied to conversation history, memory retrievals, and tool outputs, with configurable compression levels per agent instance.