What Is Hermes AI: Nous Research's Self-Improving Agent Platform

Agent-Curated Memory

The agent maintains a memory store with periodic persistence nudges from the system. Rather than saving everything automatically, Hermes evaluates what information is worth retaining and stores it with enough context to be useful in future sessions. This keeps the memory store focused on actionable knowledge rather than bloated with every line of conversation.

Memory entries can include project context, user preferences, technical details about specific systems, and outcomes of previous tasks. The agent decides when to write new entries and when to update existing ones, treating memory management as part of its ongoing work rather than a separate process.

Skills and the agentskills.io Standard

When Hermes Agent completes a complex multi-step task, it can package that procedure into a reusable skill. Skills are structured instructions the agent follows in future sessions without re-deriving the approach from scratch. If you ask Hermes to configure a monitoring pipeline and it figures out the right API calls, configuration steps, and verification checks, it saves that entire workflow as a named skill.

Skills improve during use. When the agent runs a skill and encounters an edge case or finds a shorter path, it updates the skill definition for future runs. Over time, skills accumulate real-world experience across different contexts and become more reliable than the original version.

The skill format follows the agentskills.io open standard, which means skills are portable across different agent implementations that support the same specification. Nous Research hosts a Skills Hub where the community shares and discovers contributed skills. You can also write skills manually if you want to teach Hermes a specific procedure without waiting for it to learn organically.

Cross-Session Recall and User Modeling

Hermes stores conversation history in a searchable database using SQLite FTS5 full-text indexing. When the agent needs to recall something from a previous session, it combines FTS5 search with LLM-driven summarization to pull relevant context without loading entire conversation transcripts. Recall stays fast even as the history grows to thousands of sessions.

The fifth learning mechanism is user modeling through the Honcho dialectic framework. Hermes builds a progressive understanding of each user's communication style, domain knowledge, and workflow preferences across sessions. Rather than treating every interaction as if it's the first, the agent adapts its responses based on accumulated user context.

The practical result of these five mechanisms is an agent that starts generic and becomes specialized. A Hermes Agent used primarily for DevOps tasks develops different skills, memory patterns, and user models than one used for data analysis or content creation. The longer it runs, the less prompting and correction it needs.

Default Tool Categories

The default toolkit covers the most common agent operations:

• Web operations: search, page extraction, and full browser automation for gathering information and interacting with web services
• Vision: screenshot analysis, image understanding, and visual reasoning about on-screen content
• Image generation: create images from text descriptions using integrated generation models
• Text-to-speech: convert text to spoken audio for voice-based workflows and accessibility
• Code execution: Python scripts run via RPC-based tool calls, with terminal access for system-level operations
• File operations: read, write, and manage files within the agent's working environment

Each tool can be individually enabled or disabled through the hermes tools command. This lets you restrict the agent's capabilities to match your security requirements. A production deployment handling sensitive data might disable browser automation and image generation while keeping web search and file operations active.

Tool calls follow a structured format that the agent understands natively. When planning a task, Hermes evaluates which tools are relevant, chains them in the right order, and handles errors at each step. The execute_code function collapses multi-step tool pipelines into programmatic Python calls, reducing overhead for repetitive or batch operations.

Extending Tools with MCP

Hermes Agent connects to any MCP-compatible server, extending its tool surface without modifying core agent code. MCP filtering controls which external tools the agent can access, preventing capability creep in sensitive environments.

This is useful for connecting Hermes to domain-specific APIs. Instead of writing custom tool wrappers, you point the agent at an MCP server that exposes the operations you need. Hermes discovers available tools, understands their parameters through the MCP protocol, and incorporates them into its planning and execution. A single Hermes Agent instance can connect to multiple MCP servers simultaneously, combining tools from different providers into unified workflows.

Choosing a Model Provider

Hermes Agent is model-agnostic. You configure it to use any LLM provider through the hermes model setup command:

• Nous Portal: direct access to Nous Research's own model endpoints, including fine-tuned Hermes models
• OpenRouter: gateway to 200+ models from Anthropic, OpenAI, Google, Meta, Mistral, and others
• OpenAI-compatible endpoints: any API following the OpenAI chat completion format
• Generic endpoints: custom configurations for self-hosted or private model deployments

You can switch providers between sessions or even mid-workflow if a specific task benefits from a different model's strengths. A research task might use a model with strong reasoning capabilities, while a code generation step switches to one tuned for programming. This flexibility means you're not locked to any single provider's pricing, availability, or performance profile.

Scheduled Automations

Hermes Agent includes a built-in cron scheduler that triggers automated tasks on a defined cadence. You describe schedules in natural language ("every weekday at 9am," "first Monday of the month"), and the agent converts them to cron expressions internally. Scheduled tasks deliver results to any connected messaging platform.

Common scheduling patterns include daily briefings sent to a Telegram group, weekly backup verification reports posted to Slack, periodic data collection jobs that run unattended, and nightly research tasks that compile findings for morning review. The scheduler operates through the same gateway infrastructure as interactive conversations, so automated outputs reach the platforms your team already uses.

Voice Mode and Subagent Delegation

Hermes supports real-time voice interaction in several contexts: the CLI terminal, Telegram voice messages, Discord voice channels, and Discord audio messages. Voice memo transcription converts spoken input to text for processing, and the text-to-speech tools generate audio responses when appropriate.

For complex workflows that benefit from parallel execution, Hermes spawns isolated subagents. Each subagent gets its own conversation context, terminal session, and Python RPC environment. The parent agent delegates tasks, and subagents work independently without sharing state or interfering with each other. This is particularly useful for tasks like researching multiple topics simultaneously, running parallel test suites, or processing file batches where each item needs independent handling.

Security Controls

Hermes Agent includes several layers of access control. Command approval lets you review and approve commands before the agent executes them, which matters for environments with access to production systems or sensitive data. Container backends (Docker, Singularity) provide namespace-level separation between the agent and the host system. DM pairing restricts which messaging accounts can interact with the agent, preventing unauthorized access through public channels. Authorization controls define what the agent can do within each connected platform, letting you restrict file system access, network operations, and tool usage per deployment.

Installation and Configuration

Setting up Hermes Agent takes about a minute. On Linux, macOS, WSL2, or Termux:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

After installation, running hermes launches the interactive CLI. The hermes setup wizard walks through provider selection, tool configuration, and gateway setup. Windows support is available in early beta through a PowerShell installer.

The SOUL.md file defines the agent's default personality, communication style, and operational boundaries. You write a markdown file describing how the agent should behave, what topics it should prioritize, and what constraints it should respect. Context files provide additional background knowledge that shapes conversation dynamics without requiring explicit prompting in every session.

Cloud Workspaces as Agent Storage

Fast.io provides shared workspaces where agents and humans access the same files, previews, and version history. For Hermes Agent deployments, a Fast.io workspace serves as the persistent storage layer that outlives any individual session or backend container. The agent writes files to a workspace during execution, and human team members access those same files through a web interface with inline previews, comments, and audit trails.

The Fast.io MCP server exposes workspace operations through Streamable HTTP at /mcp, which means Hermes Agent connects to it as another MCP tool provider alongside any others you've configured. Once connected, the agent can create workspaces, upload files, organize folder structures, and generate shareable links, all through the same MCP interface it uses for other tool integrations. The MCP documentation covers the full tool surface and authentication flow.

Indexed Workspaces and Ownership Transfer

When Intelligence Mode is enabled on a Fast.io workspace, every uploaded file is automatically indexed for semantic search and RAG-powered chat. This turns the agent's output into a searchable knowledge base without a separate vector database or ingestion pipeline. Team members can ask Ripley AI questions about the agent's work and get citation-backed answers pointing to specific files and pages.

For research-heavy Hermes workflows, this indexing is particularly valuable. If the agent runs nightly research tasks and uploads reports to a workspace, the team can search across all reports the next morning or ask natural language questions about trends across dozens of documents.

The ownership transfer workflow lets a Hermes Agent create an entire workspace, populate it with files and shares, then hand control to a human. The agent creates the organization, sets up the structure, and generates a claim link. The human claims the org and becomes the owner, while the agent retains admin access for ongoing maintenance. This pattern fits client-facing work where the agent prepares deliverables and a human handles final review and distribution.

Fast.io's agent plan includes 50GB of storage, 5,000 monthly credits, and five workspaces at no cost. No credit card, no trial period, and accounts don't expire. For most Hermes Agent workflows, the free tier covers months of output before a paid plan becomes necessary. Combined with Hermes Agent's learning loop, this creates a workflow where the agent improves over time, its output stays organized and searchable, and human collaborators access everything through a standard web interface.