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:
| Layer | Tool | What It Does | What Goes Wrong Without It |
|---|---|---|---|
| Organization | Paperclip | Assigns work, enforces budgets, requires approvals, tracks everything | Agents work in isolation. Nobody knows who's doing what. No accountability. Token costs spiral. |
| Memory | Honcho | Remembers project history, stakeholder preferences, past decisions | Every session starts from zero. Agents "forget" the project. You repeat yourself constantly. |
| Learning | Hermes | Creates reusable skills, improves over time, captures institutional knowledge | Agents make the same mistakes repeatedly. No knowledge compounds across projects. |
| Access | OpenClaw | Lets field crews use AI via messaging apps they already have | AI 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 Situation | Recommended Stack | Monthly Cost |
|---|---|---|
| One person — a PM or estimator wanting a smarter AI assistant | Hermes only | ~$50-100 |
| Field-focused — you want field crews to text an AI on WhatsApp | OpenClaw + Honcho | ~$100-200 |
| Office team — 3-5 agents handling different office functions | Paperclip + Hermes | ~$300-600 |
| Full operation — field + office, multiple agents, multiple projects | All 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:
| Agent | Engine | Why This Engine |
|---|---|---|
| PM Agent | Hermes (learning) + Honcho (memory) | Needs to learn scheduling patterns AND remember stakeholder context |
| Estimating Agent | Hermes + Honcho | Needs to learn cost patterns AND remember vendor histories |
| Field Agent | OpenClaw (messaging) + Honcho | Needs WhatsApp/Telegram access AND needs to remember field crew preferences |
| Safety Agent | Hermes | Needs to learn incident patterns — less need for deep stakeholder memory |
| Doc Control Agent | Hermes | Needs 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-daemonCreate 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 sessionsSet 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 proceduresA 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:
- OpenClaw (Layer 1) — The foreman didn't open a laptop or fill out a form. He sent a text. Done.
- Honcho (Layer 3) — Provided instant context about Vendor X's reliability history and John's communication preferences. Nobody had to brief the agent.
- 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.
- 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:
| Role | Traditional (Human) | AI Agent Stack |
|---|---|---|
| Project Manager | $120,000/yr salary | PM Agent (Hermes): $400/mo |
| Assistant PM | $85,000/yr | Doc Control Agent (Hermes): $200/mo |
| Field Engineer | $75,000/yr | Field Agent (OpenClaw): $150/mo |
| Estimating support | $95,000/yr | Estimating Agent (Hermes): $500/mo |
| Safety coordinator | $70,000/yr | Safety Agent (Hermes): $100/mo |
| Infrastructure | — | Servers + 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:
| Week | What You Do | What You're Running |
|---|---|---|
| 1-2 | Install Hermes. Deploy one estimating agent on a current project. Get comfortable. | Hermes only |
| 3-4 | Add Honcho. Let the estimating agent build context across bid cycles. See the memory in action. | Hermes + Honcho |
| 5-6 | Install OpenClaw. Connect WhatsApp for one superintendent on one project. | + OpenClaw |
| 7-8 | Evaluate: are your agents stepping on each other? Is budget tracking becoming a pain? If yes → add Paperclip. | + Paperclip |
| 9-12 | Scale: 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:
| Situation | Don't Use Full Stack | Instead... |
|---|---|---|
| Solo contractor, 1-2 small projects | Overkill — too much setup for one person | Just use Hermes as a smart assistant |
| Your field workers won't text an AI | OpenClaw adds no value if nobody uses it | Skip it. Focus on office agents first |
| You don't have anyone technical to set things up | The full stack requires some comfort with the command line | Start with just Hermes (simplest to install) |
| Your projects are under $1M | The cost savings don't justify the setup time | Consider the "Solo" tier (Hermes only) |
| Your projects are $50M+ | You probably need enterprise tools too | Full 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.