v0.3.0

Hermes Agent v0.3.0 — The Streaming, Plugins & Provider Release

Overview

v0.3.0 — The Streaming, Plugins & Provider Release. Released March 17, 2026, just 5 days after the first public release v0.2.0. This was the version that transformed Hermes Agent from a promising open-source agent into a production-grade autonomous operations platform.

If v0.2.0 showed the world what Hermes could do, v0.3.0 made it feel like a polished product. Streaming token delivery eliminated the “staring at a blank screen” problem. The plugin architecture opened the door for community contributions without touching core code. And the provider system rebuild meant you could hot-swap between OpenAI, Anthropic, OpenRouter’s 200+ models, or any custom endpoint with a single command.

The community response was immediate and massive: by the time this release shipped, Hermes Agent was already being called “the operating system for autonomous operations” by the Zero-Human Companies community. Here’s what made that possible.

Key stats: ~50+ bug fixes · 14 major features · 10+ new skills · 4 messaging platform overhauls

Major Features

1. Unified Streaming Infrastructure

The single most user-visible change in v0.3.0: responses now stream token-by-token across CLI and all gateway platforms. No more waiting for full responses on long operations.

What changes:

  • Every provider now streams through a unified infrastructure
  • CLI, Telegram, Discord, Slack, and all gateway platforms receive tokens as they’re generated
  • Long-running tool calls (code execution, web scraping) stream progress in real-time

This wasn’t just a cosmetic improvement — it fundamentally changed the interaction model. Users could now interrupt mid-generation, redirect the agent, or ask clarifying questions without waiting for a complete response block.

# Streaming is now the default — no configuration needed
hermes
> Write a Python script that processes a 10GB log file

# Tokens stream as they're generated. You can:
# - See exactly what the agent is thinking in real-time
# - Interrupt with Ctrl+C if it's going the wrong direction
# - Redirect mid-generation: "actually, use Rust instead"

2. First-Class Plugin Architecture

The plugin system was the unlock for community growth. Drop Python files into ~/.hermes/plugins/ and Hermes picks them up automatically — custom tools, slash commands, lifecycle hooks, all without forking the repo.

What a plugin looks like:

# ~/.hermes/plugins/my_custom_tool.py
from hermes.plugin import Plugin, tool

class MyCustomPlugin(Plugin):
    """A plugin that adds a custom weather tool."""

    @tool
    def get_weather(self, city: str) -> dict:
        """Get current weather for a city."""
        import requests
        resp = requests.get(f"https://api.weather.example/{city}")
        return resp.json()

    @tool
    def analyze_sentiment(self, text: str) -> dict:
        """Analyze sentiment of a text string."""
        # Your custom logic here
        return {"sentiment": "positive", "score": 0.85}

Plugin lifecycle hooks:

  • on_load — runs when the plugin is first loaded
  • on_unload — cleanup before removal
  • on_tool_call — intercept and modify any tool call
  • on_response — post-process agent responses

The plugin directory is automatically watched for changes — add, remove, or modify plugin files while Hermes is running and changes take effect immediately.

3. Native Anthropic Provider

Before v0.3.0, using Claude models meant routing through OpenRouter. The native Anthropic provider changed everything.

What it unlocks:

  • Direct Anthropic API calls — lower latency, no OpenRouter middleman
  • Claude Code credential auto-discovery — if you’ve used Claude Code, Hermes finds your credentials automatically
  • OAuth PKCE flows — secure, standards-compliant authentication with token refresh
  • Native prompt caching — Anthropic’s prompt caching reduces costs for long conversations by up to 90%
# Run setup with Anthropic provider
hermes setup --provider anthropic

# Or switch to it mid-session
/hermes model claude-sonnet-4-20250514

# Hermes auto-detects Claude Code credentials if available
# No API key needed if you've used Claude Code on this machine
# hermes.config.yaml
providers:
  - name: anthropic
    provider: anthropic
    model: claude-sonnet-4-20250514
    prompt_caching: true

The native provider also brought Anthropic’s native vision API support for auxiliary calls — images go through Claude’s vision model directly instead of routing through OpenAI-compatible endpoints.

4. Smart Approvals + /stop Command

Inspired by Codex’s approach to command safety, the smart approval system learns which commands are safe and remembers your preferences.

How it works:

  • First time: Hermes asks “Approve this command? [y/n/always]”
  • Choose “always”: Hermes remembers the command pattern and never asks again
  • Pattern matching: similar commands are recognized automatically
  • /stop: kills the current agent run immediately, no questions asked
> Run: pip install pandas numpy scikit-learn
# First time: "Approve this pip install command? [y/n/always]"
# Choose 'a' (always) → never asked for pip install again

> Run: rm -rf /tmp/build-cache
# "Approve this deletion? [y/n/always]" — different category, asks again
# Choose 'y' (yes this time) → asked again next time for rm commands

The /stop command gives you an emergency brake:

# Agent is going down a wrong path — stop immediately
/stop

# Or from a messaging platform (Telegram/Discord/etc.)
# Just type /stop in any conversation with Hermes

5. Voice Mode

Voice mode landed in v0.3.0 across three surfaces:

CLI: Push-to-Talk

# Press and hold Space to talk, release to send
hermes --voice

# Or toggle voice mode mid-session
/voice

Messaging Platforms: Voice Notes

  • Send voice notes on Telegram or Discord — Hermes transcribes and responds
  • Transcriptions use faster-whisper for free local processing
  • No cloud transcription service required

Discord Voice Channels

  • Hermes can join Discord voice channels
  • Listens for mentions and responds verbally
  • Falls back to text in channels without voice
# hermes.config.yaml — voice configuration
voice:
  stt:
    enabled: true
    engine: faster-whisper  # local, free, no API key needed
  tts:
    enabled: true
    engine: openai  # or any compatible TTS endpoint

6. Concurrent Tool Execution

Multiple independent tool calls now run in parallel via ThreadPoolExecutor.

Before v0.3.0:

> Search for docs on Python async, Rust async, and Go goroutines
# Tool calls execute sequentially:
# [search: python async] → wait → [search: rust async] → wait → [search: go goroutines]
# Total: ~9 seconds

After v0.3.0:

> Search for docs on Python async, Rust async, and Go goroutines
# Tool calls execute in parallel:
# [search: python async] ┐
# [search: rust async]   ├─ all start simultaneously
# [search: go goroutines]┘
# Total: ~3 seconds

This was especially impactful for research workflows, multi-file code changes, and any task involving multiple independent operations.

7. Honcho Memory Integration

Honcho (by @erosika) brought dialectic user modeling to Hermes — the agent builds a theory-of-mind model of you over time.

Key capabilities:

  • Async memory writes — memory operations never block agent responses
  • Configurable recall modes — control how many memories are injected per turn
  • Session title integration — memories are tagged with session context
  • Multi-user isolation — in gateway mode, each user’s memories are fully isolated
# hermes.config.yaml
memory:
  honcho:
    enabled: true
    recall_mode: recent  # recent | relevant | all
    max_memories_per_turn: 5

Combined with the improved memory prioritization system (user preferences now weighted above procedural knowledge), Hermes became significantly better at remembering who you are and what you care about.

8. PII Redaction

Privacy-first by design. When privacy.redact_pii is enabled, personally identifiable information is automatically scrubbed before context is sent to LLM providers.

# hermes.config.yaml
privacy:
  redact_pii: true

What gets redacted:

  • Email addresses → [EMAIL]
  • Phone numbers → [PHONE]
  • Credit card numbers → [CREDIT_CARD]
  • API keys and tokens → [API_KEY]
  • IP addresses → [IP_ADDRESS]

Redaction happens locally before any data leaves your machine.

9. /browser connect via CDP

Attach browser tools to a live Chrome instance through Chrome DevTools Protocol. Instead of Hermes launching its own browser, it connects to yours — debugging, inspecting, and interacting with pages you already have open.

# Start Chrome with remote debugging enabled
chrome --remote-debugging-port=9222

# In Hermes, connect to it
/browser connect --port 9222

# Now Hermes can:
# - See what tabs you have open
# - Navigate to new pages
# - Click, type, scroll on pages
# - Extract data from your open tabs
# - Debug web applications you're working on

This was a game-changer for web development workflows — debug your app in Chrome while Hermes watches and helps.

10. Vercel AI Gateway Provider

Route Hermes through Vercel’s AI Gateway for access to their model catalog and infrastructure.

# hermes.config.yaml
providers:
  - name: vercel
    provider: vercel-ai-gateway
    api_key: ${VERCEL_AI_GATEWAY_KEY}

This was strategically important: Vercel’s gateway provides unified billing, rate limiting, and analytics across multiple model providers, making it ideal for teams and production deployments.

11. Centralized Provider Router

The provider system was completely rebuilt around a single call_llm API. Every model call — main agent, subagents, vision, auxiliaries — routes through one chokepoint.

What this enables:

  • Unified /model command — switch models and providers with one command, Hermes auto-detects the provider
  • Auto-detect on model switch — type /model claude-sonnet-4 and Hermes knows it’s Anthropic
  • Direct endpoint overrides — point vision or subagent calls at specific endpoints independently
  • Custom provider resolution — delegation providers resolve from custom_providers config
# Switch models seamlessly
/hermes model gpt-5          # → OpenAI
/hermes model claude-sonnet-4 # → Anthropic (auto-detected)
/hermes model grok-3          # → xAI
/hermes model nous-hermes     # → OpenRouter or Nous Portal

# Prefix matching works too
/mod gpt-5    # resolves to /model gpt-5

12. ACP Server — IDE Integration

VS Code, Zed, and JetBrains can now connect to Hermes as an agent backend through the Agent Communication Protocol.

# Start Hermes in ACP server mode
hermes serve --acp

# VS Code / Zed / JetBrains extensions connect to this endpoint
# Full slash command support available in the IDE

This meant developers could access their personal Hermes agent directly from their editor — ask it to refactor code, explain functions, or generate tests without leaving the IDE.

13. Persistent Shell Mode

By @alt-glitch. Local and SSH terminal backends maintain shell state across tool calls.

Before:

> cd /my-project
> ls
# (new shell spawned, `cd` didn't persist)
# Shows home directory, not /my-project

After:

> cd /my-project
> ls
# (same shell, state persists)
# Shows /my-project contents ✓
> export DATABASE_URL=postgres://localhost/mydb
> python manage.py migrate
# DATABASE_URL is set ✓

Shell sessions persist cd, environment variables, aliases, and working directory across all tool calls in a conversation. SSH backends get the same treatment.

14. Agentic On-Policy Distillation (OPD)

New RL training environment for distilling agent policies, expanding the Atropos training ecosystem. This was part of Hermes’s dual purpose: it’s not just a tool for end users, but also infrastructure for generating agentic trajectories used to train the next generation of tool-calling models.

# The OPD environment lives in environments/
# Integrates with Nous's Atropos RL framework
# Generates training data from agent behavior trajectories

CLI & User Experience Improvements

Interactive CLI Upgrades

Feature Description
Persistent Status Bar Always-visible model, provider, and token counts
File Path Autocomplete Tab-complete file paths in the input prompt
/plan Command Generate implementation plans from specs
/rollback Improvements Richer checkpoint history, clearer UX
Prefix Matching /mod → /model, /sta → /status
Skill Preloading Skills loaded on launch, ready before first prompt

Setup & Configuration

  • OpenClaw migration — seamless migration from OpenClaw during first-time setup
  • Headless setup — full setup flow works on SSH-only servers
  • Smart vision setup — respects your chosen provider for vision capabilities
  • .env reload — environment changes picked up without restart

Platform Updates

Gateway Core

Feature Impact
System Service Mode Run as systemd system-level service
Reasoning Hot Reload Change reasoning settings without restart
Per-User Session Isolation Group chats no longer share state across users
SSL Auto-Detection Works on NixOS and non-standard systems
Gateway Restart Recovery Improved resume after crashes

Telegram

  • Media group buffering prevents photo burst interruptions
  • Retry on transient TLS failures
  • Proper MarkdownV2 escaping for special characters

Discord

  • /thread command with auto_thread config
  • Auto-thread creation on @mention
  • Native document and video attachment support preserved

Slack

  • Complete thread handling overhaul — responses and session isolation respect threads
  • Max message length fix (3900 → 39000)
  • File upload fallback preserves thread context

Email

  • IMAP UID tracking and SMTP TLS verification fixes
  • skip_attachments option via config.yaml

Tools & Infrastructure

New Skills Added

Skill Description
Linear Project management integration
X/Twitter Social media via x-cli
Telephony Twilio SMS and AI calls
1Password Password management (by @arceus77-7)
NeuroSkill BCI Brain-computer interface integration
Blender MCP 3D modeling
OSS Security Forensics Security analysis toolkit
Parallel CLI Research skill
OpenCode CLI skill
ASCII Video Refactored (by @SHL0MS)

MCP Improvements

  • Selective tool loading — filter which MCP tools are available with utility policies
  • Auto-reload — MCP tools reload when mcp_servers config changes, no restart needed
  • npx connection fixes — resolved stdio connection failures

Cron System

  • Single cronjob tool replaces multiple commands
  • Jobs persist to SQLite — survive restarts
  • Per-job runtime overrides (provider, model, base_url)
  • Atomic writes prevent data loss on crash
  • Thread context preserved for deliver=origin

Security Hardening

  • Tirith pre-exec scanning — static analysis of commands before execution
  • Provider env var stripping — all provider/gateway env vars removed from subprocess environments
  • Docker cwd opt-in — host directory mounts now explicit, never automatic
  • Fork bomb detection — improved regex patterns for malicious command detection

Key Bug Fixes

v0.3.0 closed over 50 issues. The most impactful fixes:

Issue Fix
/status showed 0 tokens Now reports live state and token counts
Custom model endpoints broken Restored config-saved endpoint resolution
MCP tools invisible until restart Auto-reload on config change
hermes tools removing MCP tools Preserves MCP toolsets when saving
Terminal subprocesses inheriting OPENAI_BASE_URL Env vars stripped from all subprocesses
Gateway performance degradation Fixed log handler accumulation
Background process lost on restart Improved recovery
Cron jobs not persisting Now stored in SQLite
Setup hanging on headless SSH End-to-end headless flow
Model switching not taking effect Fixed provider resolution on switch

What the Community Said

“Hermes is not a coding copilot tethered to an IDE. It’s not a chatbot wrapper around a single API. It’s a persistent, multi-platform, multi-model autonomous agent that grows with its deployment.” — ZHC Institute, Field Notes on v0.3.0

“The agent that accumulates” — Hermes Agent’s defining characteristic was already visible in v0.3.0: skills created from experience, memory curated over time, capability growing with each interaction. — Intraview, Hermes Agent Origin Story

Breaking Changes

  • Provider configuration format updated — custom provider configs from v0.2.0 may need restructuring
  • Legacy OpenClaw configs must go through the migration flow (hermes claw migrate)
  • Plugin API is new in v0.3.0 — no breaking changes from prior versions (plugins didn’t exist before)

Upgrade

hermes update

Migrating from OpenClaw:

# If you're coming from OpenClaw, use the migration command
hermes claw migrate

For new installations, visit the install guide.

Full changelog on GitHub

← Hermes Agent Changelog