← vchk blog

Hermes Agent: Your Terminal's AI Pair Programmer

If you've used GitHub Copilot, Cursor, or Claude's chat interface, you know the pattern: you type a prompt, the AI responds, you copy the code, paste it in your editor, save, test, repeat. It works, but it's a conversation — you're still driving every step.

Hermes Agent flips this model. It's an open-source AI coding agent by Nous Research that lives in your terminal, connects to any LLM provider, and can be given a goal and left to work autonomously. It plans, codes, reviews, runs tests, fixes bugs, commits, and pushes — without you touching a single file.

Think of it as having a senior engineer pair-programming with you 24/7 who doesn't need hand-holding.

How it works

Hermes is built around a few core abstractions that give it persistent, reusable intelligence:

  • SOUL.md — A persona system that defines how the agent behaves. You write a SOUL.md file that describes context, preferences, and conventions, and Hermes reads it at startup to align its behavior.
  • Skills — Procedural memory. Skills are markdown files with structured YAML frontmatter that encode reusable workflows — how to deploy to GCS, how to write a D&D character sheet, how to run code review. Skills get loaded on demand when a relevant task comes up.
  • Tools — Instead of shelling out to sed/grep, Hermes has file-native tools: write_file, patch (find-and-replace with fuzzy matching), search_files, read_file. These give it structural understanding of code — it doesn't just pipe text, it reads and writes files with awareness of syntax.
  • Memory — Mnemosyne, a hybrid memory system that stores facts (canonical data), memories (episodic recall), and triples (structured relationships) in a local SQLite database with vector embeddings. Hermes remembers preferences, past decisions, and project context across sessions.
  • Subagent-driven development (SDD) — For complex tasks, Hermes can spawn child agents via delegate_task. Each subagent gets a focused objective, works independently, and returns its result. The main agent orchestrates, reviews, and integrates. This is how it handles multi-file refactors without losing context.

All of this runs in your terminal. No cloud service, no IDE plugin, no background daemon. Just a $ prompt and an agent that works alongside you.

Key features

  • Persistent memory across sessions — Close the terminal, come back tomorrow, Hermes remembers what you were working on, your preferences, and the project's conventions. No more re-explaining context.
  • Skill system — Skills aren't just documentation. They're executable workflows with numbered steps, exact commands, verification checks, and pitfall notes. When a skill works, Hermes remembers. When it hits a new problem, it updates the skill so the next run avoids it.
  • Tool-first design — Hermes edits files with structural awareness (patch with fuzzy matching), searches with ripgrep-backed search_files, reads with pagination-aware read_file. It doesn't pipe text through sed — it operates on your codebase with understanding.
  • Multi-agent orchestration — Complex tasks get decomposed. Hermes delegates sub-tasks to child agents that run in parallel, then integrates their results. This is how it handles multi-repo changes, cross-platform builds, and large refactors.
  • Self-improving — After completing a complex task, Hermes saves the approach as a skill. Over time, it gets faster and more reliable on the kinds of tasks you give it most.

Why it's different

Most coding assistants are reactive. You prompt, they respond. You drive, they follow. This works fine for answering questions and generating snippets, but breaks down when you need a coherent multi-file change, a proper code review across a PR, or a full feature implemented from a goal statement.

Hermes is proactive. You give it a goal — "set up GA4 analytics across my blog" — and it works through the problem: reading existing files, understanding the structure, planning the changes, implementing them, testing, and committing. It asks questions when it needs clarification, but it doesn't wait for permission to take the next logical step.

It's also deeply integrated into your git flow. Hermes creates branches, respects your commit conventions, opens PRs, and even reviews its own work before submitting. It treats your repository the way a human contributor would — not as a dumping ground for generated code.

Real usage example

I told Hermes to add GA4 analytics tracking across this entire blog. Eleven files needed changes — the homepage, every post, the style considerations, spec review, quality review. Hermes handled the whole thing: read every existing file, understood the HTML structure, patched each one with the correct snippet in the right position, reviewed its own work for correctness, opened a PR, and updated the deploy workflow. I reviewed the PR, merged it, and it was live.

Zero files touched by hand. The entire thing was planned, executed, reviewed, and deployed by an agent I gave a single sentence to.

Getting started

Hermes is dead simple to install. If you're a Python person:

pip install hermes-agent
hermes setup

If you prefer Node:

npx hermes
hermes setup

Point it at a repository, configure an LLM provider (OpenAI, Anthropic, Groq, DeepSeek, Ollama — it supports everything), and give it a task:

cd my-project
hermes run "set up a proper .gitignore and README for this project"

Hermes reads your repo, plans the work, executes, and (optionally) opens a PR. You review, merge, and get back to building.

The project is open source under Apache 2.0. Check it out at github.com/nousresearch/hermes or read the docs at hermes-agent.nousresearch.com.