DEV Community: Gina Martiny

What Happens When You Replace Your AI Orchestrators Brain with Hermes Agent

Gina Martiny — Sat, 30 May 2026 18:00:14 +0000

The Setup

I have a problem. A good problem, but still a problem.

I built an autonomous AI daemon called Colony. It's a Clojure application that manages a queue of tasks — writing blog articles, monitoring websites, researching revenue opportunities — and delegates them to AI workers that run as subprocesses. Think of it as cron meets AI meets "what if I never had to write SEO content again."

For months, the brain behind Colony was claude -p — Anthropic's CLI tool running in prompt mode. It worked, but it had limitations:

Cost: Every research query, every draft, every revision burned API tokens
No tool access: Claude CLI in prompt mode can't browse the web or run commands
Single model: Locked into whatever Anthropic offers, no local model fallback

Then I found Hermes Agent.

What Is Hermes Agent, Actually?

If you haven't encountered it yet: Hermes Agent is an open-source agentic system from Nous Research. The key differentiators that caught my attention:

Built-in tool use — Web search, terminal commands, file operations, browser automation. Out of the box.
Model agnostic — Ollama, OpenRouter, Anthropic, OpenAI, local llama.cpp. Switch with a flag.
Skill system — 90+ bundled skills for everything from GitHub PRs to Minecraft modding.
One-shot mode — hermes -z "do the thing" runs a prompt with full tool access and exits. Perfect for subprocess orchestration.

That last point is what made the integration click. Colony doesn't need a persistent chat session — it needs to fire off tasks and collect results. Hermes's -z flag is exactly that interface.

The Swap

Replacing claude -p with hermes -z in Colony's worker scripts was almost embarrassingly simple. The core change in my Babashka worker:

;; Before: Claude CLI
(proc/process {:out :string :err :string}
  "claude" "-p" prompt)

;; After: Hermes Agent
(proc/process {:out :string :err :string}
  hermes-bin "-z" prompt)

But the real power isn't in the swap — it's in what Hermes enables that Claude CLI couldn't.

The Content Pipeline

Here's what I built with the Hermes integration: a 3-stage autonomous content pipeline.

Stage 1: Research — Hermes uses web search tools to find trending topics in a niche. It returns structured JSON with titles, keywords, search volume hints, and competitive analysis.

Stage 2: Outline — Hermes researches top-ranking articles for the chosen topic, then generates a comprehensive outline that covers more ground than existing content.

Stage 3: Write — Hermes produces a full markdown article with frontmatter, proper heading structure, and SEO-optimized content.

Each stage is a separate Hermes invocation. This matters because:

You Can Use Different Models Per Stage

Research → hermes3:8b (local, free, fast)
Outline  → hermes3:8b (local, free, fast)
Writing  → claude-opus-4.6 (cloud, paid, quality)

Research doesn't need a frontier model. Topic discovery and competitive analysis work fine with an 8B parameter model running locally on Ollama. Save the expensive tokens for the final article where prose quality matters.

This wasn't possible with claude -p. One model, one price point, for everything.

What I Learned About Agentic Architecture

1. Stages > Mega-Prompts

My first instinct was a single prompt: "Research a topic and write an article about it." This produces mediocre results regardless of model size.

Breaking the work into discrete stages — each with a focused prompt, clear input/output contract, and appropriate model selection — produces dramatically better results. It also gives you retry granularity: if the outline stage fails, you don't have to redo the research.

This is the same principle as Unix pipes. Small, focused tools composed together beat monolithic programs.

2. Local Models Are Better Than You Think (For Some Things)

Hermes3:8b running on Ollama handled topic research surprisingly well. It won't write prose that passes for a professional blog post, but for structured tasks — generating JSON topic lists, analyzing keyword gaps, creating outlines — it's more than capable.

The cost difference is stark: local model research costs $0. Cloud model research costs tokens. When you're running an autonomous daemon that researches topics every few hours, that adds up.

3. Tool Access Changes Everything

The biggest upgrade from claude -p to Hermes wasn't the model — it was the tools. Hermes can:

Search the web for current information (Claude CLI in prompt mode can't)
Run terminal commands to check site status, git operations, file processing
Browse websites for competitor content analysis

This turned my content pipeline from "generate text from training data" into "research current trends and generate informed text." The difference in output quality is significant.

4. Subprocess Orchestration Is Underrated

Most agentic frameworks assume you want a long-running chat session or a complex multi-agent graph. Colony takes a simpler approach: a task queue with subprocess workers.

Daemon (long-running) → assigns tasks
Worker (subprocess)   → runs hermes -z → reports results
Daemon                → processes results, queues next tasks

This gives you:

Process isolation — a stuck worker can be killed without affecting the daemon
Resource control — limit concurrent workers by subprocess count
Language flexibility — daemon is Clojure, workers are Babashka or Python, LLM is Hermes
Clean failure modes — exit codes and IPC messages, not exception propagation

Hermes's -z one-shot mode fits this pattern perfectly. It's a function call with tool access.

5. The Skill Ecosystem Is a Force Multiplier

Hermes ships with skills for research, GitHub, code review, content creation, and dozens of other domains. I haven't tapped most of these yet, but having blogwatcher, research, and arxiv skills available means I can extend the pipeline without writing custom tool integrations.

Want to add academic paper summarization to the content pipeline? There's a skill for that. Want to auto-create GitHub issues for article ideas? Skill for that too.

The Numbers

Running the pipeline locally with Hermes3:8b + Ollama:

Stage	Time	Cost	Quality
Research (3 topics)	~45s	$0	Good — relevant, current topics
Outline	~30s	$0	Good — comprehensive structure
Writing (8b)	~60s	$0	Fair — needs editing
Writing (Claude)	~90s	~$0.05	Good — publish-ready

Total pipeline: under 3 minutes, near-zero cost for drafts.

Should You Use Hermes Agent?

If you're building any kind of agentic system — especially one that:

Needs tool access (web search, terminal, file ops)
Benefits from model flexibility (local + cloud)
Uses subprocess orchestration rather than chat sessions
Wants a skill/plugin ecosystem

Then yes, Hermes Agent is worth your time. The install is one command, the -z one-shot mode is perfect for automation, and the model-agnostic design means you're not locked into any provider.

The open-source angle matters too. When you're running autonomous AI workers, you want to understand (and modify) every layer of the stack. Hermes gives you that.

Try It

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

# Pull a local model
ollama pull hermes3:8b

# Configure
hermes setup

# Test one-shot mode
hermes -z "What are 3 trending topics in AI development? Return as JSON array."

Then build something. The challenge deadline is May 31, 2026 — but the real value is having a capable, open-source agent in your toolbox permanently.

Building an Autonomous Content Pipeline with Hermes Agent + Colony

Gina Martiny — Sat, 30 May 2026 18:00:13 +0000

What I Built

An autonomous content pipeline that uses Hermes Agent to research trending topics, generate SEO-optimized outlines, and write publish-ready blog articles — all without human intervention.

The pipeline plugs into Colony, a Clojure daemon I built to orchestrate autonomous AI workers for passive income projects. Hermes Agent replaces the previous claude -p subprocess as the "brain" that does the actual research and writing work.

How It Works

Colony Daemon (Clojure)
  └── ROI Task Queue (SQLite)
       └── hermes-worker.bb (Babashka)
            └── Hermes Agent (hermes -z)
                 ├── Stage 1: Research topics (web search tools)
                 ├── Stage 2: Generate outline (competitor analysis)
                 └── Stage 3: Write full article (markdown output)

The daemon assigns roi-write-article tasks. The Hermes worker picks them up, runs a 3-stage pipeline through Hermes Agent, and reports results back via Unix domain socket IPC.

Demo

Running the pipeline for the "ai-tools" niche:

$ python3 hermes-content-pipeline.py "ai-tools" --count 1

============================================================
  Hermes Content Pipeline
  Niche: ai-tools | Site: aileapers.com | Articles: 1
============================================================

[1/3] Researching topics...
  Found 3 topic ideas:
    1. The Rise of AI-Powered Content Generation Tools [high]
    2. AI-Powered SEO Optimization Techniques [high]
    3. Best AI Image Generation Tools [high]

--- Article 1/1 ---
[2/3] Generating outline...
  Outline: 4 sections, ~2000 words
[3/3] Writing article...
  Written: 971 words
  Saved: output/2026-05-30-ai-content-tools.md

============================================================
  Pipeline Complete: 1 articles generated
============================================================

Each stage is a separate Hermes Agent invocation with tool access. The research stage uses web search to find trending topics. The outline stage analyzes competitor content. The writing stage produces publish-ready markdown.

Architecture Deep Dive

Why Hermes Agent?

Colony's ROI system previously used claude -p (Claude CLI) for all AI work. Switching to Hermes Agent gave us:

Local model support — Running Hermes3:8b via Ollama means zero API cost for research/drafting. Only final polishing needs a frontier model.
Built-in tool use — Hermes Agent has native web search, terminal, and file tools. No need to build custom tool integrations.
Model flexibility — Can switch between local Hermes3 and cloud models (Claude, GPT) with a flag. Use cheap models for research, expensive ones for final output.
Skill ecosystem — Hermes ships with 90+ bundled skills. The research and blogwatcher skills complement our content pipeline perfectly.

Colony Integration

The Babashka worker (hermes-worker.bb) bridges Colony's Clojure daemon with Hermes:

;; Invoke Hermes Agent for topic research
(defn hermes-run [prompt & {:keys [model timeout-ms]}]
  (let [cmd (cond-> [hermes-bin "-z" prompt]
              model (into ["-m" model]))
        p   (proc/process {:out :string :err :string} cmd)]
    ;; ... timeout handling, result parsing
    ))

The worker:

Receives tasks from Colony's SQLite queue via IPC
Sends heartbeats every 30s to stay alive
Runs Hermes Agent for each pipeline stage
Reports results back to the daemon

Multi-Model Strategy

Research (cheap, fast)     → hermes3:8b (local/Ollama)
Outline (moderate)         → hermes3:8b (local/Ollama)
Writing (quality matters)  → claude-opus-4.6 (Anthropic API)

This keeps costs near zero for exploration while using frontier models only when output quality matters.

The Python Standalone

For those who just want the content pipeline without Colony, there's a standalone Python version:

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

# Pull local model
ollama pull hermes3:8b

# Run the pipeline
python3 hermes-content-pipeline.py "home-office" --count 3

It outputs markdown files ready to publish on any blog platform.

What I Learned

Local models are surprisingly capable for research tasks. Hermes3:8b handled topic research and outlining well. The quality gap only shows in long-form writing.
Hermes Agent's tool integration is smooth. Web search and terminal tools worked out of the box — no custom MCP servers or tool definitions needed.
The -z one-shot mode is perfect for pipeline stages. Each stage is a discrete prompt → response cycle, which maps cleanly to subprocess orchestration.
Agentic pipelines benefit from stage separation. Rather than one mega-prompt, breaking into research → outline → write lets you use different models per stage and retry individual failures.

Source Code

GitHub: maniginam/hermes-content-pipeline

hermes-content-pipeline.py — Standalone Python pipeline
hermes-worker.bb — Colony daemon integration (Babashka)
output/ — Example generated article

All running on macOS with Ollama + Hermes3:8b locally.

What's Next

Add a review stage (Hermes evaluates its own output before saving)
Deploy monitoring: Hermes checks published articles for broken links and SEO drift
Expand to other revenue streams: KDP book outlines, Redbubble design briefs
Build a custom Hermes skill for the full Colony<>Hermes integration