Writing
The Agent Stack: Paperclip + Honcho + OpenClaw + Hermes

The Agent Stack: Paperclip + Honcho + OpenClaw + Hermes

The Problem: Four Different Problems

If you've been following this series, you've seen four different tools solving four different problems:

  • Paperclip — organizes AI agents into teams with roles, budgets, and accountability
  • Honcho — gives AI agents long-term memory so they don't forget project context
  • OpenClaw — lets field crews interact with AI through WhatsApp and Telegram
  • Hermes — creates AI agents that learn and improve from every project

Each is powerful alone. But here's the thing — they're designed to work together. And when they do, you get something none of them can deliver individually.

Think of it like building a house. You need a foundation (memory), walls (the agents themselves), a roof (organization), and doors (how people get in and out). You could build just the walls, and you'd have something. But a wall by itself isn't a house.


What Each Layer Does (And What Goes Wrong Without It)

An Analogy That Makes This Click

Imagine a construction company where:

  • Paperclip is the org chart and the management structure — who reports to whom, what everyone's budget is, who approves what
  • Honcho is the company's collective memory — every meeting note, every lesson learned, every stakeholder preference
  • Hermes is the training program — employees who get better at their jobs every week
  • OpenClaw is the phone system — how field workers communicate with the office

Take away any one of these, and the company still functions, but poorly. Take away all of them, and you have chaos.

Here's what each layer does, and what goes wrong without it:

LayerToolWhat It DoesWhat Goes Wrong Without It
OrganizationPaperclipAssigns work, enforces budgets, requires approvals, tracks everythingAgents work in isolation. Nobody knows who's doing what. No accountability. Token costs spiral.
MemoryHonchoRemembers project history, stakeholder preferences, past decisionsEvery session starts from zero. Agents "forget" the project. You repeat yourself constantly.
LearningHermesCreates reusable skills, improves over time, captures institutional knowledgeAgents make the same mistakes repeatedly. No knowledge compounds across projects.
AccessOpenClawLets field crews use AI via messaging apps they already haveAI is limited to office workers with laptops. 60% of the project team can't use it.

Do You Need All Four? (Probably Not Yet)

Here's the honest answer: start with one tool, not four. Deploy all four on day one and you'll spend more time configuring than getting value. Start with whichever layer solves your most immediate problem.

Which Setup for Which Situation

Your SituationRecommended StackMonthly Cost
One person — a PM or estimator wanting a smarter AI assistantHermes only~$50-100
Field-focused — you want field crews to text an AI on WhatsAppOpenClaw + Honcho~$100-200
Office team — 3-5 agents handling different office functionsPaperclip + Hermes~$300-600
Full operation — field + office, multiple agents, multiple projectsAll four tools~$800-2,000
⚠️

The costs above are AI model usage only (how much you pay Anthropic/OpenAI per month based on how much your agents process). The tools themselves are all free and open-source. Infrastructure (a server to run them on) adds $20-75/month depending on your setup.


The Full Stack: How Everything Connects

For a mid-sized GC (general contractor) running the complete stack, here's the architecture:

Why different agents use different engines:

AgentEngineWhy This Engine
PM AgentHermes (learning) + Honcho (memory)Needs to learn scheduling patterns AND remember stakeholder context
Estimating AgentHermes + HonchoNeeds to learn cost patterns AND remember vendor histories
Field AgentOpenClaw (messaging) + HonchoNeeds WhatsApp/Telegram access AND needs to remember field crew preferences
Safety AgentHermesNeeds to learn incident patterns — less need for deep stakeholder memory
Doc Control AgentHermesNeeds to learn RFI and submittal patterns

Wiring It Together: Step by Step

Install Everything

# 1. Paperclip — the organizational layer
npx paperclipai onboard --yes
# Now running at http://localhost:3100
 
# 2. Honcho — the memory layer
docker run -d --name honcho \
  -p 8000:8000 \
  -e DATABASE_URL=postgres://honcho:honcho@localhost:5432/honcho \
  ghcr.io/plastic-labs/honcho:latest
# Now running at http://localhost:8000
 
# 3. Hermes — the learning agent engine
curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
hermes model set anthropic/claude-sonnet-4
 
# 4. OpenClaw — the messaging interface
npm install -g openclaw@latest
openclaw onboard --install-daemon

Create the Project Company in Paperclip

Every project gets its own "company" in Paperclip — keeping budgets, goals, and data isolated:

curl -X POST http://localhost:3100/api/companies \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Harbor View Mixed-Use",
    "mission": "Deliver Harbor View on schedule ($8.2M GMP) with zero lost-time incidents."
  }'

Set Up the Memory Workspace in Honcho

Create a dedicated memory space for this project, and register the key people and agents:

import honcho
 
# One workspace per project — keeps memories separate
workspace = honcho.Workspace.create(
    name="harbor-view-mixed-use",
    metadata={
        "project_value": 8200000,
        "start_date": "2026-04-01",
        "completion_date": "2027-06-30"
    }
)
 
# Register everyone the agents will interact with
# Humans:
workspace.create_peer(
    name="John_Superintendent",
    type="human",
    metadata={"role": "superintendent", "phone": "+1-555-0147"}
)
workspace.create_peer(
    name="Sarah_Henderson_Design",
    type="human",
    metadata={"role": "architect", "avg_rfi_response_days": 8}
)
 
# AI Agents:
workspace.create_peer(
    name="PMAgent",
    type="ai",
    metadata={"role": "project_manager", "adapter": "hermes"}
)
workspace.create_peer(
    name="FieldBot",
    type="ai",
    metadata={"role": "field_communications", "adapter": "openclaw"}
)

Hire Agents in Paperclip

Each agent uses the engine that best fits its role:

# Estimating Agent — uses Hermes (learns cost patterns over time)
npx paperclipai agent create \
  --company-id <company-id> \
  --name "EstimatingAgent" \
  --adapter hermes_local \
  --title "Chief Estimator" \
  --role manager \
  --adapter-config '{
    "model": "anthropic/claude-sonnet-4",
    "persistSession": true,
    "toolsets": ["terminal", "file-ops", "web"],
    "checkpoints": true
  }'
 
# Field Agent — uses OpenClaw (accessible via WhatsApp)
npx paperclipai agent create \
  --company-id <company-id> \
  --name "FieldBot" \
  --adapter openclaw_gateway \
  --title "Field Communications" \
  --role ic \
  --adapter-config '{
    "gatewayUrl": "ws://localhost:18789",
    "channels": ["whatsapp", "telegram"]
  }'
 
# PM Agent — uses Hermes (learns scheduling patterns)
npx paperclipai agent create \
  --company-id <company-id> \
  --name "PMAgent" \
  --adapter hermes_local \
  --title "Project Manager" \
  --role manager \
  --adapter-config '{
    "model": "anthropic/claude-sonnet-4",
    "persistSession": true,
    "toolsets": ["terminal", "file-ops", "web", "browser"]
  }'

Connect Honcho Memory to Agent Heartbeats

When Paperclip wakes up an agent, the agent first loads relevant memory from Honcho before starting work:

# This runs at the start of every agent heartbeat
import honcho
import os
 
# Connect to the project's memory workspace
workspace = honcho.Workspace.get(name="harbor-view-mixed-use")
agent_peer = workspace.get_peer(name=os.environ["PAPERCLIP_AGENT_ID"])
 
# Ask Honcho: "What do I need to know about this task?"
task_id = os.environ["PAPERCLIP_TASK_ID"]
context = workspace.chat(
    peer=agent_peer,
    query=f"What do I need to know about task {task_id}? "
          f"Include relevant stakeholder preferences and project history."
)
 
# Now the agent starts work with FULL project context —
# it remembers everything from previous sessions

Set Budgets and Approvals

# Monthly budgets per agent (controls AI API costs)
npx paperclipai budget set --agent EstimatingAgent --monthly 500
npx paperclipai budget set --agent FieldBot --monthly 150
npx paperclipai budget set --agent PMAgent --monthly 400
 
# Require human approval for sensitive actions:
# - Sending any email/message to external parties
# - Any financial commitment (change orders, POs)
# - Any change to safety procedures

A Complete Example: From Field Text to Resolved Issue

Let's trace a single event through all four layers to see how they work together:

Scenario: A foreman texts on WhatsApp that a steel delivery is delayed 3 days.

What each layer contributed:

  1. OpenClaw (Layer 1) — The foreman didn't open a laptop or fill out a form. He sent a text. Done.
  2. Honcho (Layer 3) — Provided instant context about Vendor X's reliability history and John's communication preferences. Nobody had to brief the agent.
  3. Hermes (Layer 2) — Applied a skill it had learned from 3 prior schedule delays. It didn't start from scratch — it knew the recovery pattern.
  4. Paperclip (Layer 4) — Tracked the issue, linked it to a strategic goal, routed it to the right agent, and logged everything in an audit trail.

No single tool could do all of that. Without OpenClaw, the foreman would need a laptop. Without Honcho, the agent wouldn't know Vendor X's history. Without Hermes, the agent would have to figure out schedule recovery from scratch every time. Without Paperclip, there'd be no tracking, no goal linkage, and no audit trail.


Cost Analysis: Full Stack vs. Traditional Team

For a mid-sized GC running an $8M commercial project:

RoleTraditional (Human)AI Agent Stack
Project Manager$120,000/yr salaryPM Agent (Hermes): $400/mo
Assistant PM$85,000/yrDoc Control Agent (Hermes): $200/mo
Field Engineer$75,000/yrField Agent (OpenClaw): $150/mo
Estimating support$95,000/yrEstimating Agent (Hermes): $500/mo
Safety coordinator$70,000/yrSafety Agent (Hermes): $100/mo
InfrastructureServers + Paperclip + Honcho: $50/mo
AI model costs~$400/mo across all agents
Total per year$445,000~$21,600
⚠️

These Agents Don't Replace Humans

Let me be very clear: this table shows what's theoretically possible, not what you should do. AI agents handle data processing, pattern matching, scheduling analysis, and documentation — the 60-70% of office work that's repetitive. But you still need:

  • A superintendent on site making judgment calls about safety and quality
  • A project manager making strategic decisions and managing client relationships
  • Humans signing contracts and taking legal responsibility

A realistic deployment: keep your PM and superintendent, defer hiring the assistant PM, field engineer, and estimating support roles. That's still ~$225K/year in savings on a single project.


Where Everything Runs

Total infrastructure cost: ~$50-75/month (before AI model usage). That's less than most people's phone bill.


The 90-Day Rollout Plan

Don't try to deploy everything at once. Here's a week-by-week plan:

WeekWhat You DoWhat You're Running
1-2Install Hermes. Deploy one estimating agent on a current project. Get comfortable.Hermes only
3-4Add Honcho. Let the estimating agent build context across bid cycles. See the memory in action.Hermes + Honcho
5-6Install OpenClaw. Connect WhatsApp for one superintendent on one project.+ OpenClaw
7-8Evaluate: are your agents stepping on each other? Is budget tracking becoming a pain? If yes → add Paperclip.+ Paperclip
9-12Scale: add more agents (PM, safety, doc control). Set budgets and governance rules.Full stack

By week 12, you have a governed, memory-rich, self-improving, field-accessible AI team running alongside your human staff. And you built it one layer at a time, validating each layer before adding the next.


When NOT to Use the Full Stack

Being honest about limitations:

SituationDon't Use Full StackInstead...
Solo contractor, 1-2 small projectsOverkill — too much setup for one personJust use Hermes as a smart assistant
Your field workers won't text an AIOpenClaw adds no value if nobody uses itSkip it. Focus on office agents first
You don't have anyone technical to set things upThe full stack requires some comfort with the command lineStart with just Hermes (simplest to install)
Your projects are under $1MThe cost savings don't justify the setup timeConsider the "Solo" tier (Hermes only)
Your projects are $50M+You probably need enterprise tools tooFull stack + Procore/Autodesk integration

Conclusion

No single tool solves the "AI in construction" problem. You need:

  • Organization — so agents don't work in chaos
  • Memory — so agents don't forget everything every session
  • Learning — so agents get smarter over time
  • Access — so the people who need AI most can actually use it

Paperclip, Honcho, Hermes, and OpenClaw each solve one of these cleanly. Together, they compose into something that doesn't exist yet in the construction industry: an AI workforce that coordinates, remembers, learns, and meets people where they work.

Start with one layer. Add the next when you feel the gap. The stack grows with you — just like Hermes does.