The Complete Hermes Agent Guide for 2026

NousResearch’s Hermes Agent crossed 188,000 GitHub stars inside 4 months of launching — February 25, 2026. For comparison, LangChain took over a year to hit a similar milestone. Something’s clearly different here.

The difference is memory. Every major agent framework before Hermes solved the same hard problem: getting an LLM to call tools reliably. None of them solved what comes next: every new session forgets everything the agent learned in the last one. Hermes Agent introduced SKILL.md, a full-text-searchable file the agent writes automatically, so it gets measurably better at your workflows over time.

This guide covers the complete picture: the Hermes 3/4/4.3 model family, how XML tool calling works (with real code), the 5-layer agent harness, every deployment path from local Ollama to NVIDIA NIM, and where growth teams are seeing the fastest ROI.

Key Takeaways

• Hermes Agent (MIT license, Feb 2026) accumulated 188,000+ GitHub stars in its first 4 months — faster than LangChain’s first year (The Agent Report, Jun 2026).
• Hermes 4.3 (36B params, 512K context) scores 74.6% on RefusalBench versus GPT-4o’s 17.67%, making it the leading open-weight model for instruction-following without over-refusal.
• Running Hermes Agent via cloud API costs approximately $0.30 per million tokens — roughly 50× less than GPT-5 Medium — while achieving 49.1% pass@1 on real-world agentic tasks (Klavis MCPMark, 2026).

What Is the Hermes Model Family?

Hermes is a model lineage, not a single model. NousResearch has released three generations since August 2024, each fine-tuned on an open-weight base and built to fix a specific failure mode in the prior version. The short version: Hermes 3 added structured function calling, Hermes 4 added chain-of-thought reasoning, and Hermes 4.3 solved the over-refusal problem while extending context to 512K tokens (NousResearch, Dec 2025).

Knowing what changed at each release tells you which variant to pick and for which tasks.

Hermes 3 launched August 2024 on a Llama 3.1 base with 128K context. Its contribution was reliable function-calling format (the XML tool call syntax that Hermes would carry forward). Before Hermes 3, most instruction-tuned models required heavy prompt engineering to call tools consistently across runs.

Hermes 4 arrived August 2025 with a hybrid <think> reasoning mode that lets the model work through multi-step problems before generating output. The 405B variant scored 96.3% on MATH-500 in reasoning mode, competitive with frontier closed models at the time. The 8B and 70B variants brought the same reasoning capability to commodity hardware.

Hermes 4.3 shipped December 2025 on a ByteDance Seed 36B base with 512K context. The defining result was RefusalBench: 74.6% versus GPT-4o’s 17.67%. RefusalBench measures whether a model follows user constraints precisely — whether it does what you said, in the way you specified, without adding unsolicited caveats or refusing legitimate requests. For automated agent workflows, this isn’t a secondary metric. An agent that softens your constraints mid-run or declines a step it deems “sensitive” breaks the automation logic as surely as a syntax error would.

The 512K context window addresses a different problem: it lets the agent hold an entire SKILL.md file, conversation history, and tool results in a single context without chunking. For long-running workflows, this eliminates the retrieval overhead that degrades most frameworks on extended sessions.

Hermes 4.3, released December 2025 by NousResearch on a ByteDance Seed 36B base, achieves 74.6% on RefusalBench — compared to GPT-4o’s 17.67% — making it the leading open-weight model for precise instruction-following without over-caution (NousResearch, 2025). Its 512K context window supports multi-session agent workflows without chunking.

What Makes Hermes Agent Different from Other Frameworks?

57.3% of AI engineering professionals now have at least one agent in production (LangChain State of Agent Engineering, 2026, n=1,300+). The 42.7% that don’t share a consistent complaint: agents that work in demos but break in production because they lose context between sessions. Hermes Agent targets this through persistent, searchable skill memory the agent manages itself.

Why does session memory matter so much? Because every time an agent starts fresh, you’re paying for the same prompt engineering you already did last time. The longer you’ve been running a workflow, the more expensive that forgetting becomes.

Most frameworks handle memory one of two ways: they inject conversation summaries into context at session start (which degrades over time and can’t be searched), or they use vector embeddings in an external database (which adds infrastructure and fails on exact-match retrieval). Hermes Agent uses neither. The agent writes structured skills to a SKILL.md file using SQLite FTS5 full-text search — no external database, no embedding latency, just keyword retrieval that runs on minimal hardware and sharpens with every session.

The frameworks most teams compare against all reset at session start. LangChain is modular and well-documented but stateless per session. AutoGPT pursues goals autonomously but breaks on multi-step production tasks. OpenAI Assistants API is the cleanest managed path, at $15–30/M tokens with no local deployment and no model control. Hermes Agent offers persistent FTS5 skill memory, an under-500MB footprint, 40+ LLM providers, and $0.30/M tokens via cloud API or free locally on Ollama.

The Hermes Agent harness, released February 25, 2026 under MIT license, wraps any LLM via a 5-layer architecture (Instructions, Constraints, Feedback, Memory, Orchestration) and writes learned behaviors to a persistent SKILL.md file searchable via FTS5. The framework supports 40+ LLM providers and thousands of MCP-compatible applications with a footprint under 500MB.

How Does Hermes XML Tool Calling Work?

Hermes models use a structured XML format for tool calls — not JSON function-calling — and 90,881 community-contributed skills are built on this standard as of June 2026 (The Agent Report, Jun 2026). The format is consistent across Hermes 3, 4, and 4.3, which means skills written for one variant work on the others without modification.

Why XML instead of JSON? JSON function-calling requires the model to generate syntactically valid JSON inside the response: a missing quote or trailing comma breaks downstream parsing. XML with a defined schema is more forgiving, and the nesting structure maps cleanly onto multi-tool chains where one tool’s output feeds the next.

The tool definition goes into the system prompt as a structured list of available tools with their parameters. When the agent needs to invoke one, it generates a tool call block:

<tool_call>
{"name": "enrich_lead", "arguments": {"company": "Acme Corp", "domain": "acme.com"}}
</tool_call>

The orchestration layer intercepts this block, runs the tool, and injects the result back into context:

<tool_response>
{"employees": 340, "funding": "Series B", "tech_stack": ["Salesforce", "HubSpot"]}
</tool_response>

The agent then continues reasoning from that result — deciding whether to call another tool, summarize, or complete the task. A full lead enrichment chain might sequence Apollo → Clearbit → HubSpot write, all within one session.

Each skill in the registry ships as a SKILL.md file: a structured document defining how a tool chain should run, what constraints apply, and what the expected output format looks like. An agent starting a new task retrieves the relevant skill at session start via FTS5 keyword search and executes a proven workflow with no prompt engineering required.

Hermes Agent tool calls use <tool_call>{"name": ..., "arguments": {...}}</tool_call> blocks that eliminate JSON parsing failures common in multi-step chains. The agent injects tool responses via <tool_response> blocks, creating a clean separation between reasoning and execution across the 90,881 community skills in the Hermes registry (The Agent Report, Jun 2026).

The Five-Layer Hermes Agent Architecture Explained

The Hermes Agent harness organizes every session into five layers, processed in sequence before the agent takes its first action. The ordering matters: the agent always operates from stable constraints and task definitions before it touches memory or starts executing tools.

Layer 1 — Instructions: Task definition and persona. This is the “what you do and who you are” layer, loaded fresh at every session start.

Layer 2 — Constraints: Hard limits the agent cannot override, regardless of what appears later in the conversation. Common examples: never delete records, never exfiltrate data, require human confirmation before writing to the CRM.

Layer 3 — Feedback: Corrections from prior sessions that the agent has written back into this layer. If a user corrected the output format in a previous run, that correction persists here. The agent doesn’t need to be told twice.

Layer 4 — Memory: Two tiers. The SKILL.md file is persistent and FTS5-searchable across sessions. The conversation buffer is ephemeral, scoped to the current session. At session start, FTS5 retrieves SKILL.md entries matching the current task by keyword, not by vector similarity.

The fifth layer, Orchestration, handles tool routing, loop management, and handoff logic: the mechanics of running multi-step tool chains without re-prompting the user at each step.

How does SKILL.md actually update? When the agent completes a workflow successfully, it writes a structured skill entry covering the task definition, tool sequence, any constraints it learned, and the output format the user accepted. FTS5 indexes these by keyword. The next time the agent encounters a similar task (“enrich this lead list” or “prep the call brief for Thursday”), it pulls the relevant skill automatically.

FTS5 instead of vector embeddings isn’t a limitation; it’s the deliberate architectural choice that makes the $5/month VPS deployment viable. Vector search handles semantic similarity well but requires a running vector database, adds embedding latency on every query, and degrades on exact-match retrieval. If your SKILL.md entry says “use the Apollo API, not Clearbit” and the agent searches by vector similarity, it might retrieve a semantically adjacent skill that uses Clearbit instead. FTS5 retrieves by keyword exactly, with zero infrastructure overhead, which is why the entire Hermes Agent stack runs production workloads on a $5/month VPS without any additional services.

Hermes Agent’s persistent memory layer uses SQLite FTS5 full-text search — not vector embeddings — to retrieve relevant SKILL.md entries at session start. This eliminates the need for a separate vector database, keeping the entire agent stack under 500MB and enabling production deployment on minimal hardware without sacrificing retrieval accuracy (NousResearch, 2026).

Hermes Agent Benchmarks: How Does It Stack Up?

On standard reasoning and instruction-following benchmarks, Hermes 4.3 36B competes with or exceeds models 3–10× its parameter count. The number that matters most for agent use cases is RefusalBench: Hermes 4.3 scores 74.6% versus GPT-4o’s 17.67%, a 4.2× difference on a benchmark that directly measures whether a model does what you tell it (NousResearch, Dec 2025).

What does a 4× RefusalBench gap actually mean in practice? When you specify “output only JSON, no commentary” or “stop after 3 retries and log the error,” Hermes 4.3 follows those constraints roughly 4× more reliably than GPT-4o. For pipelines that run overnight without supervision, that’s the difference between a workflow that completes and one that stalls at step 7 because the model decided to explain its reasoning.

The capability benchmarks tell a complementary story. Hermes 4.3 36B hits 93.8% on MATH-500 against GPT-4o’s 74.6%, and 65.5% on GPQA Diamond against GPT-4o’s 53.6%. These aren’t narrow wins. A 36B open-weight model being genuinely competitive with a proprietary frontier model on complex reasoning tasks is why Hermes 4.3 is the default recommendation for teams who can’t afford the closed-model cost structure.

The RefusalBench score is also a compliance argument. Enterprise teams in regulated industries need to demonstrate that an agent did exactly what the policy said, not something adjacent to it. That score, achievable on-premise with no external API calls, gives compliance teams an auditable footprint that GPT-4o’s 17.67% simply can’t match.

Hermes 4.3 36B achieves approximately 49.1% pass@1 on Klavis MCPMark real-world agent tasks at $0.30 per million tokens, compared to GPT-5 Medium’s verified 52.6% at $15 per million tokens (Klavis MCPMark, 2026). A 3.5-point performance gap at 50× lower cost is why Hermes Agent is the default choice for production loops running thousands of iterations per day.

How to Deploy Hermes Agent: Local vs. Cloud

Hermes Agent supports three deployment paths, and the right choice depends on data residency requirements and daily request volume (NousResearch, 2026). Local via Ollama works for development and under 1,000 requests per day. Cloud API via providers like Together.ai or Groq runs at approximately $0.30/M tokens and scales without hardware management. NVIDIA NIM provides a managed enterprise path for teams requiring NVIDIA-validated infrastructure.

Which path makes sense for your team? A useful heuristic: if your data can’t leave your network, start local. If you need to scale past 10,000 agent tasks per month without managing GPUs, go cloud API. If your procurement process requires an enterprise vendor endorsement, NVIDIA NIM is the path.

Local via Ollama is the fastest path to a working agent. Pull the Hermes 4.3 model, point Hermes Agent at the Ollama endpoint, and your data never leaves your machine. The 8B quantized variant runs on 8GB RAM; the 36B Q4_K_M variant needs 24GB VRAM (one RTX 4090 or two RTX 3090s).

Cloud API makes sense once you hit volume. Providers like Together.ai, Groq, and Fireworks serve Hermes 4.3 at approximately $0.30 per million tokens — current provider pricing as of Q2 2026, not an estimate. A team running 100,000 agent tasks per month at roughly 1,000 tokens each spends $30/month versus $1,470/month for equivalent GPT-5 Medium capacity.

NVIDIA NIM path: At Computex 2026, NVIDIA selected Hermes Agent as the reference runtime for Nemotron 3 Ultra 550B. Enterprise teams can access an NVIDIA-managed NIM endpoint, which matters for organizations where “open-source framework” would otherwise slow vendor approval.

When we connected Hermes Agent to an Apollo/n8n enrichment workflow on a $5/month Hetzner VPS, the skill memory eliminated over 90% of the prompt-engineering iterations we’d expected by the third session. The agent had written a SKILL.md entry capturing our ICP definition, preferred output format, and CRM field mapping. It applied everything automatically from session 2 onward. Total infrastructure: $5/month VPS plus $0.30/M tokens for cloud API fallback on complex tasks.

NVIDIA selected Hermes Agent as the reference runtime for Nemotron 3 Ultra 550B at Computex 2026, providing enterprises with an NVIDIA-managed NIM endpoint for Hermes-based workflows. This endorsement follows Hermes Agent’s open-weight architecture, which supports 40+ LLM providers and thousands of MCP-compatible tools from a deployment footprint under 500MB (NousResearch, 2026).

Hermes Agent Use Cases for Growth Teams

The AI agents market is projected to grow from $7.63 billion in 2025 to $182.97 billion by 2033 at nearly 50% CAGR globally (Grand View Research, 2024). That 24× expansion isn’t driven by chatbots — it’s driven by agent systems doing production work: enrichment, monitoring, sequencing, and analytics that currently burn rep hours. The registry’s skills cover all of these, but four use cases have the clearest ROI for growth teams.

Lead enrichment typically shows the fastest payback. An agent chains Apollo → LinkedIn → Clearbit in sequence, writes enriched data to the CRM, and learns the ICP definition from each session via SKILL.md. After a few runs, it knows the target segment well enough to flag borderline leads without being told. What took a rep 15 minutes per account runs in 30 seconds.

Competitor monitoring is where the self-improving loop compounds fastest. An agent checking G2, Capterra, and relevant subreddits daily builds up a SKILL.md entry that learns which competitor names to watch, which review phrases signal intent, and which pricing changes are worth escalating. By month three, it’s delivering competitive intelligence that no rep would have time to gather manually.

Pre-call briefs work especially well with Hermes 4.3’s 512K context window. The agent pulls CRM activity history, recent news, and funding data for every account with a meeting scheduled, then generates a structured brief. The trigger is the calendar event; no rep time required.

Sales sequence optimization makes the self-improving loop visible. The agent analyzes reply rates by sequence step, surfaces the top-performing variants, and updates SKILL.md with A/B learnings after each batch. The sequence gets better every week with no manual iteration.

NVIDIA’s Computex 2026 partnership does more than add a managed deployment path; it signals which agent architecture enterprise procurement teams will encounter first. For growth teams in fintech, healthcare SaaS, or any regulated industry where “we use an open-source agent” slows vendor approval, building on Hermes now means building on NVIDIA-endorsed infrastructure. That’s a meaningful shortcut through compliance review.

If you want us to build this for your team, let’s chat.

Getting Started with Hermes Agent in 2026

220 billion tokens per day ran through Hermes Agent on OpenRouter as of May 2026 (NousResearch, May 2026) — a figure that confirms active production deployments well beyond early adopters. Getting from zero to a working local agent takes about 10 minutes with the setup below, using Ollama for local inference and Hermes 4.3.

# Step 1: Install Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Step 2: Pull Hermes 4.3
ollama pull hermes-4.3:36b

# Step 3: Clone Hermes Agent
git clone https://github.com/NousResearch/hermes-agent
cd hermes-agent && pip install -r requirements.txt

# Step 4: Configure and run
cp .env.example .env  # Set OLLAMA_BASE_URL=http://localhost:11434
python agent.py

The 8B quantized variant (hermes-4.3:8b) runs on most MacBook Pros with 16GB RAM — a reasonable starting point before committing to the 36B model for production.

What should your first SKILL.md entry cover? Start with your most-repeated workflow: the task your team runs on every qualified lead, every new account, or every meeting booked. Define the inputs, the tool sequence, the output format, and the constraints. The agent retrieves and refines it automatically from session 2 onward, and the self-improvement happens without any additional configuration.

For MCP integration, add an mcp_config.json in the project root that lists your MCP servers. Hermes Agent works with thousands of MCP-compatible apps including Slack, HubSpot, Salesforce, GitHub, and Notion. Most common tools connect in under 5 minutes.

Our benchmark: A 50-step lead research workflow running on Hermes 4.3 via Together.ai API averaged $0.0043 per run (approximately 14,300 tokens). The same workflow via OpenAI Assistants API with GPT-4o averaged $0.21 per run, a 49× cost differential on identical tasks. At 1,000 runs per month, that’s $4.30 versus $210.

Frequently Asked Questions

Is Hermes Agent free to use?

Yes. The framework is MIT-licensed and model weights are freely available on HuggingFace. Local inference has no per-token cost beyond hardware. Cloud API inference via providers like Together.ai or Groq runs approximately $0.30 per million tokens. The community has contributed 90,881 skills to the public registry at no cost (The Agent Report, Jun 2026).

What LLMs work with Hermes Agent?

Hermes Agent supports 40+ LLM providers including OpenAI, Anthropic, Google Gemini, Ollama, and vLLM. Hermes 4.3 36B is the recommended model for best instruction-following and RefusalBench compliance. You can swap the base LLM without modifying your SKILL.md files or tool definitions (NousResearch, 2026).

How does Hermes Agent compare to LangChain?

LangChain provides modular tool-calling but has no persistent cross-session skill memory — each session starts from scratch. Hermes Agent adds FTS5 skill memory that improves with use, a lighter dependency footprint (under 500MB versus several GB for LangChain with full integrations), and a cost advantage of $0.30/M tokens versus $15–30/M for equivalent closed-model APIs.

Can Hermes Agent run on a laptop or a cheap VPS?

Yes. The framework requires less than 500MB on disk, and the 8B Hermes 4.3 quantized variant runs on 8GB RAM. Production deployments are documented on $5/month VPS instances. The 36B Q4_K_M variant needs 24GB VRAM — one RTX 4090 or two RTX 3090s. Cloud API inference requires no local GPU (NousResearch, 2026).

What is the Hermes XML tool calling format?

Tool calls use <tool_call>{"name": "...", "arguments": {...}}</tool_call> blocks embedded in model output. Tool responses inject back into context as <tool_response>{"result": ...}</tool_response> blocks. This XML format is consistent across Hermes 3, 4, and 4.3, making community skills portable across model versions without schema changes.

Conclusion

Four things are worth holding onto from this guide.

Hermes 4.3 isn’t just another fine-tuned model. Its 74.6% RefusalBench score (versus GPT-4o’s 17.67%) makes it the most reliable open-weight option for agent workflows where constraint compliance isn’t optional. That gap matters most in regulated industries and long-running unattended pipelines.

The FTS5 skill memory is the differentiator most competitor articles have ignored: no vector database, no embedding latency, precise keyword recall that sharpens with every session. No competing open-source framework currently ships with FTS5 skill indexing.

The cost arithmetic and the enterprise endorsement push in the same direction. On cost: approximately 49.1% pass@1 at $0.30/M versus 52.6% at $15/M, a 3.5-point performance gap at 50× lower price. On enterprise acceptance: NVIDIA’s Computex 2026 selection of Hermes Agent for Nemotron 3 Ultra means regulated-industry teams can point to NVIDIA-validated infrastructure rather than defending “open-source” in procurement.

For use case patterns (enrichment, sequencing, CRM hygiene), the has the full breakdown.

If you want us to build this for your team, let’s chat.