Building an Autonomous Content Pipeline with Hermes Agent + Colony

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:

1. Local model support — Running Hermes3:8b via Ollama means zero API cost for research/drafting. Only final polishing needs a frontier model.

2. Built-in tool use — Hermes Agent has native web search, terminal, and file tools. No need to build custom tool integrations.

3. 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.

4. 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

1. 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.

2. 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.

3. The -z one-shot mode is perfect for pipeline stages. Each stage is a discrete prompt → response cycle, which maps cleanly to subprocess orchestration.

4. 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

Comments

[Harjot Singh]

An autonomous content pipeline is a great agent use-case because content is high-volume and mostly low-stakes, exactly where autonomy pays off. The "colony" framing is interesting, multiple agents dividing the work. The thing that decides whether it produces value vs volume: a quality gate. Autonomous content pipelines are one prompt away from flooding you with plausible slop, so the win is a verify or judge step that kills the weak outputs before they ship. Volume without a quality bar is just faster mediocrity. I lean hard on that gate-the-output principle in Moonshift. How's the colony coordinating, shared state or a controller dispatching, and do you have a quality filter at the end?

[Gina Martiny]

You are totally right! At the time I submitted this there wasn't a quality gate, and props to you for calling me out on it. I hate internet slop. But! Shortly after submitting, I built a quality gate to avoid the slop, because you are right that volume without quality is just faster mediocrity.

It's a fourth stage, and the key choice is that the judge isn't the model that wrote the draft as self-evaluating agents are too generous to catch their own own slop. A separate skeptical judge grades each draft on an explicit rubric (on-topic, depth, originality, accuracy, structure, readability, and no-lies), returns a 0–100 score, and only drafts at or above the threshold ship. It fails closed: if the judge's verdict can't be parsed, the draft is rejected, never published, so a broken judge can't wave content through. A failing draft gets one revise-and-retry that targets the judge's specific objections; if it still misses, it's quarantined meaning it's kept for review; not deleted, but certainly not published.

On coordination: it's controller-dispatch, not shared state. The Colony daemon owns a SQLite task queue and hands tasks to isolated subprocess workers that report back over a Unix domain socket, which I chose for failure isolation (a stuck worker gets killed without corrupting anything else).

So: guilty as charged at submission time, but the gate was the piece I cared most about after getting it work, and it's in now.