Shipping Code with Hermes: A 7-Step Workflow for Building Your Dream App

I have AI agents that write code. Not “help me write code” — write it, commit it, open PRs, run tests, fix failures, ship.

They run on Hermes Agent (by Nous Research). Over months of sessions we built Muchiround — commerce, social, logistics, wallets, and AI on a multi-tenant Rails platform — with tool calls measured in the hundreds per hard feature, not vibes.

This is not a think piece about AI. It is a workflow you can follow. Seven steps, from install to shipped app. Each step is something we actually do.

Step 1: Install and configure

Install Hermes, then point it at your project.

pip install hermes-agent
hermes setup

The setup wizard covers model selection, tools, and messaging connections. Pick a model with strong tool-use. Then wire:

• A terminal (local shell)
• A filesystem (read/write)
• A browser (visual QA)
• The web (search, extract)

hermes setup tools
hermes setup terminal

You know it works when hermes status is green. Docs live at hermes-agent.nousresearch.com/docs.

Step 2: Write the context file

Hermes reads AGENTS.md in the project root. That file is the agent’s standing orders — what the project is, how to run it, what conventions are non-negotiable.

# Muchiround

Rails monolith with multi-tenant architecture.

## Commands
- Dev server: `bin/rails server -p 5000`
- Tests: `bundle exec rspec` (with the project Ruby on PATH)
- Linter: `bundle exec rubocop`

## Conventions
- API routes scoped under `/api/v1/<domain>/`
- Use money-rails for all currency handling
- Mobile-first, progressive disclosure UX

This file is the highest-leverage thing you will write. Every session starts here. When something goes wrong twice, the fix usually lands in AGENTS.md.

We learned that the hard way. Early on the agent did not know how Ruby was versioned on the machine. It ran bundle exec rspec, hit a version error, and burned ten minutes debugging the wrong layer. Once the correct PATH and runner lived in the context file, that class of failure stopped.

Step 3: Build memory

Hermes keeps persistent memory across sessions: user preferences and operational notes. Both inject into new sessions.

You do not hand-edit a giant config every time. The agent saves facts as it learns. You can accelerate it:

“Prefer direct execution over descriptions. Treat the money gem as the single source of truth for currencies. Mobile-first progressive disclosure. Never invent test results.”

Save facts that will still matter in six months. Do not save task progress or commit SHAs — those belong in searchable session history.

Session 100 should not re-ask which Ruby, which test runner, or whether git add -A is acceptable. Memory is how that happens.

Step 4: Run the feature loop

Core loop. Everything else is a variation.

Describe — “Add RBX fee indicators next to comment submit actions across all commentable domains.”

Investigate — Before writing code, the agent reads the repo. Search files, open views, check models and routes. No guessing. If it has not seen it in the tree, it goes and looks.

Implement — Real file edits via patch and write tools. No “here is some code to paste” theater.

Verify — Build and tests that matter:

npm run build
# or:
bundle exec rspec spec/requests/commentable_spec.rb

If tests fail, read the output, fix the root cause, re-run. Stop at green, not at “I found the problem.”

Ship — Stage relevant files, conventional commit, push, open a PR with a structured description: what changed, risk, how to verify.

A focused UI pass that used to eat an afternoon can leave as a PR in a short session. The win is not magic typing speed. It is investigation discipline plus refusal to claim done without tool output.

Step 5: Save skills

When the agent learns a non-trivial workflow, it saves a skill: markdown with exact commands, steps, and pitfalls. Matching tasks load the skill automatically.

Nudge it when something was hard:

“Save what you just did as a skill so we do not re-discover this next month.”

The first self-hosted Pelias setup cost hours of trial and error. The skill captured Compose, import order (Pelias is picky), endpoint shape, and a verification curl. Next server: minutes, not another archaeology dig.

Skills rot. When the test runner or deploy path changes, patch the skill immediately. A wrong skill is worse than no skill.

Step 6: Delegate parallel work

Some work is embarrassingly parallel. Subagents get their own conversation, terminal, and tools. Only the summary returns to the parent.

The critical rule: subagents have no memory of the parent chat. Pass full context. “Redesign the commerce views” produces mush. “In cart.html.erb, replace inline color styles with text-success, remove decorative emoji, add for on every label” produces precise work.

Batch size matters. Dumping dozens of files into one wave while the design system is still moving produces inconsistent output. Small focused batches for mechanical work; one file at a time for the tricky ones.

Step 7: Automate and review

Not everything needs you in the loop. Scheduled jobs run in a fresh session — the prompt must be self-contained:

schedule: "0 6 * * *"
prompt: "Read overnight CI failures from the last 12 hours.
         Categorize: flaky, broken, or environmental.
         For flaky tests, re-run once.
         For broken tests, open a GitHub issue.
         Post a short summary."
workdir: "/path/to/your/app"

If you cannot describe the job in a self-contained prompt, you do not understand it well enough to automate it yet.

For review: risk-categorize the diff, scan security footguns, run quality gates, leave inline comments. You still decide. Critical paths — payments, auth, migrations — get your eyes on every line. Everything else: trust the review, skim the diff.

Visual QA matters. Curl does not catch a button off-screen on mobile. A real browser session does.

The mental model

An assistant waits for instructions. A chief-of-staff style agent operates: you give intent, it gives execution inside a fence.

You are not typing every line. You are directing work, reviewing output, and compounding skills and memory so the next session is sharper than the last.

Seven steps. Install, configure, remember, build, save, delegate, automate. Each compounds. By the time the system is mature you are not “10x faster at typing” — you are operating like a small team that does not lose context overnight.

There is no trick. Files, memory, skills, and a model that follows instructions carefully. Build the system. Shipping becomes routine.

Running a full agentic company on top of this loop? Start here: The Agentic Company · Shipping production at speed · How we work.