Prerequisites: Node.js 20+, pnpm 9.15+, and an LLM provider (OpenRouter, Anthropic, or OpenAI recommended).

Introduction: The Best of Both Worlds

If you’ve been exploring the wild world of AI agents lately, you’ve probably heard of two standout tools: Paperclip and Hermes Agent. Each solves a different piece of the AI automation puzzle—and together, they’re genuinely powerful.

Here’s the thing: most AI agents today are what I call “goldfish agents.” They forget everything the moment a task ends. You explain what you want, they do it once, and next time? It’s like talking to someone with amnesia. Every. Single. Time.

Hermes Agent fixes that. It remembers. It learns. It builds skills over time through its automatic retrospective loop. It’s like hiring someone on day one who starts as a junior, and by day 30, they’re running circles around your best employee.

Paperclip fixes the coordination problem. It turns individual agents into a functioning org chart—CEO, researchers, executors—all working toward shared goals with budget enforcement and task routing.

Alone, each has limits. But combined? You get multi-agent coordination with persistent, self-improving memory at the individual agent level. That’s the “zero-human company” stack that’s been generating buzz in AI circles.

This guide walks you through setting both up, connecting them, and running a virtual team that actually gets smarter over time.

Philosophy Moment: As one speaker put it, "Collaboration between humans and AI leads to innovative solutions that benefit society at large." That's exactly what we're building here—not a replacement for human workers, but an amplification layer that handles the repetitive so we can focus on the meaningful.

Part 1: Understanding the Architecture

Before we dive in, let’s clarify what each tool brings to the table:

Dimension Paperclip Hermes Agent
Core function Multi-agent orchestration Single agent with self-improving memory
Memory None (stateless by default) Three-layer persistent memory
Skills Via adapters 80+ built-in + self-evolving
Run mode On-demand heartbeats 24/7 background
Coordination Org charts, goals, budgets N/A (single agent)

The magic is in the official adapter from Nous Research: you can run Hermes Agent as a managed employee inside Paperclip. That means Hermes retains its full memory and skills while operating within Paperclip’s coordination framework.

Part 2: Installing Hermes Agent First

We install Hermes first because Paperclip will connect to it as a runtime. Hermes is lightweight and runs on just about anything.

Step 1: Install Hermes 

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
source ~/.bashrc
hermes version

The installer handles Python, Node.js, and all dependencies. Works on macOS, Linux, WSL2, and even Termux on Android.

Alternative: If you prefer Docker: ```bash docker pull nousresearch/hermes-agent:latest docker run -v ~/.hermes:/opt/data nousresearch/hermes-agent:latest ```

Step 2: Configure Your Model

All configuration lives in ~/.hermes/config.yaml:

model:
  provider: openrouter
  api_key: sk-or-your-key-here
  model: anthropic/claude-sonnet-4

terminal: local

Supported providers: OpenRouter (200+ models), Nous Portal, OpenAI, Anthropic, z.ai/Zhipu, Ollama (fully offline).

Step 3: Verify It Works 

hermes

Ask it something simple: “What’s the current working directory?” If it responds, you’re golden.

Step 4 (Optional): Connect Telegram

For mobile access:

  1. Create a bot via @BotFather in Telegram → get your token
  2. Add to ~/.hermes/config.yaml:
gateway:
  telegram:
    token: YOUR_BOT_TOKEN

Now you have a 24/7 AI assistant reachable from your phone.

Why This Matters: "Continuous learning is crucial as technology evolves, fostering adaptability in an ever-changing landscape." Hermes embodies this—with each task, it gets better. Every failed attempt becomes a skill patch. Every success gets codified.

Part 3: Installing Paperclip

Now let’s get the orchestration layer running.

Step 1: Install Paperclip CLI 

npx paperclipai onboard --yes

This walks through setup, configures your environment, and gets Paperclip running at http://localhost:3100.

Known Issue: If you're using Claude Code, don't run Paperclip from inside a Claude Code terminal. Create a startup script to unset `CLAUDECODE` first: ```bash #!/bin/bash unset CLAUDECODE npx paperclipai onboard --yes ```

Step 2: Open the Dashboard

Navigate to http://localhost:3100 in your browser. The onboarding wizard walks you through:

  1. Creating your first company
  2. Configuring your first agent
  3. Setting a company goal
  4. Assigning a first task

Step 3: Verify the Server

You should see:

✓ Paperclip server running at http://localhost:3100
✓ API available at http://localhost:3100/api
✓ UI available at http://localhost:3100
What We've Built: "Technology should serve as a tool for empowerment rather than a source of alienation." That's exactly what Paperclip + Hermes achieves—you're building tools that amplify your capabilities, not replace your judgment.

Part 4: Connecting Hermes to Paperclip

This is where the magic happens. The official hermes-paperclip-adapter lets Hermes run as a managed employee inside your Paperclip company.

Step 1: Install the Adapter 

git clone https://github.com/NousResearch/hermes-paperclip-adapter.git
cd hermes-paperclip-adapter
pnpm install

Step 2: Register Hermes as an Agent

In the Paperclip UI at http://localhost:3100:

  1. Go to Agents → New Agent
  2. Select adapter type: hermes_local
  3. Configure the connection to point to your Hermes installation

The adapter automatically:

  • Detects your model/provider from ~/.hermes/config.yaml
  • Falls back to legacy .env format if needed
  • Maps both Paperclip-managed and Hermes-native skills

Step 3: Test the Integration

Create a simple task in Paperclip: “List files in the current directory.”

Watch the output. You should see Hermes processing the task via its full tool suite, with session persistence working via the --resume flag.

How It Works: On each heartbeat, the adapter spawns Hermes CLI in single-query mode (`-q`). Hermes processes the task, the adapter captures stdout/stderr and parses it into structured transcript entries—then reports back with token usage, cost, and session state.

Part 5: Building Your Virtual Org Chart

Now you have a working stack. Let’s build a simple “company” to demonstrate the power.

Example: Content Research Team

Let’s set up a three-agent team:

  1. CEO (Claude Opus 4.6 via Paperclip) — orchestrates everything
  2. Research Agent (Hermes) — multi-stream web research with memory
  3. Writer Agent (Hermes) — drafting, with context from research

Step 1: Create the Company

In Paperclip dashboard:

  • Name: “Content Engine”
  • Goal: “Produce high-quality blog posts weekly”

Step 2: Hire the Agents

  • Agent 1: claude_local (for high-level reasoning)
  • Agent 2: hermes_local (research specialization + memory)
  • Agent 3: hermes_local (writing specialization + memory)

Step 3: Assign Skills

Each Hermes agent gets a profile in ~/.hermes/skills/:

# research-skill
1. Search multiple sources simultaneously
2. Cross-reference facts
3. Summarize findings in markdown
4. Save to team memory

# writing-skill
1. Pull context from research agent memory
2. Follow the brand voice guide
3. Optimize for SEO
4. Save drafts to shared drive

Step 4: Watch It Run

Assign a task: “Research and write a post about container security best practices.”

The CEO delegates. Research Agent digs in, pulling from web, docs, and prior research stored in long-term memory. Writer Agent picks up the context, drafts, iterates based on feedback. Each agent remembers what worked and what didn’t.

The Big Picture: This is what "collaboration between humans and AI" actually looks like in practice. Each agent has a role. Each remembers its role. Each improves at its role. And the human stays in the loop—not as a doer, but as a reviewer, a guide, a quality controller.

Part 6: Best Practices and Gotchas

A few things to keep in mind as you build:

Memory Management

Hermes writes to SQLite after every session. The database grows. Audit ~/.hermes/ monthly:

# Check memory size
du -sh ~/.hermes/

# Search conversation history
hermes --search "keyword"

Skill Quality

Auto-improving skills depend on feedback quality. Vague feedback (“this isn’t right”) won’t improve anything. Be specific:

# Good feedback
"Next time check if the table exists first before inserting. The error was a constraint violation."

# Won't help
"I don't like how this came out."

Skill Auditing

The auto-generated rules can drift. Check your skill files periodically:

ls ~/.hermes/skills/
cat ~/.hermes/skills/research-skill.md
Important: "Transparency in AI algorithms fosters trust in technology." Both Paperclip and Hermes log everything. Review your logs. Know what your agents are doing. Stay in control.

Budget Enforcement

Paperclip lets you set spending limits per task and per agent. Use these. They’re not suggestions—they’re guardrails.

Diversity of Perspective

When building multi-agent teams, give each agent a different role, perspective, and tooling. Don’t just spawn clones.

Why This Matters: "AI's role in decision-making processes must include diverse perspectives to avoid systemic bias." Even in a small two-agent setup, different agents should have different specializations. It makes the output better and reduces blind spots.

Part 7: Going 24/7

Want your company running while you sleep? Deploy to a VPS.

Hermes on VPS 

docker run -d \
  --name hermes \
  --restart unless-stopped \
  -v ~/.hermes:/opt/data \
  nousresearch/hermes-agent:latest

Paperclip on VPS

Follow the Docker deployment guide:

docker compose -f docker-compose.quickstart.yml up --build

Set up Tailscale for secure remote access, and you’ve got a company that never sleeps.

Philosophy Moment: "The future workforce will need new skills that emphasize critical thinking and emotional intelligence." That's you—managing agents, reviewing output, providing context. The work doesn't disappear; it elevates.

Troubleshooting

Issue Solution
EADDRINUSE: address already in use :::3100 Kill the process: lsof -i :3100 or change port in config
pnpm: command not found Install with npm install -g pnpm
“nested sessions” errors Unset CLAUDECODE before running Paperclip
Hermes doesn’t remember Check ~/.hermes/ permissions; verify SQLite exists
Skills not loading Check skill files are valid markdown; restart Hermes

Summary

What we’ve built:

  • Hermes Agent → Your self-improving individual contributor with 3-layer memory
  • Paperclip → Your orchestration layer with org charts and coordination
  • hermes-paperclip-adapter → The bridge connecting them

Start with simple tasks. One agent, one goal. Let it run. Iterate. Add more agents. Watch them specialize. Let them remember.

The stack is genuinely powerful—not because either tool is magic, but because they solve different problems at the right abstraction level. Hermes remembers long-term. Paperclip coordinates short-term. Together, you get both.

One Sentence Takeaway: Balancing technology with ethics and emotional intelligence is essential for fostering human flourishing in society—and this stack, used thoughtfully, is exactly that kind of balanced technology.

Further Reading

Have questions, success stories, or gotchas to share? Drop a comment below. Happy automating!