Paperclip: The AI Control Plane for Running Construction Teams

The Problem: Smart Agents, No Manager

Imagine you hired five brilliant employees for a construction project: an estimator, a scheduler, a procurement specialist, a safety officer, and a document controller. Each one is excellent at their job. But nobody told them who's in charge. Nobody set up a reporting structure. Nobody gave them a shared budget. Nobody said, "before you spend more than $10,000, check with the boss."

What would happen? Chaos. The estimator prices a job one way, the procurement agent buys materials another way. The scheduler makes a plan the safety officer never sees. Everyone's working hard — but nobody's working together.

That's exactly what happens when you deploy multiple AI agents without an orchestration layer.

Enter Paperclip (opens in a new tab) — a free, open-source platform that acts as the management layer above your AI agents. If your AI agents are employees, Paperclip is the company they work for. It gives them an org chart, a chain of command, budgets, goals, and a human boss (you) who has final say on everything.

What Paperclip Actually Does

Paperclip isn't another chatbot, and it's not a single AI tool. It's the organizational layer that gives your fleet of AI agents:

• Org structure — roles, titles, reporting lines, and capabilities (like a company org chart)
• Goal alignment — every task traces back to a company mission, so agents know why they're doing something
• Budget enforcement — monthly cost limits per agent, with automatic alerts and hard shutoffs
• Governance — a human "Board" (that's you) with hire/fire, approve/reject, and pause/resume authority over every agent
• Full audit trail — an immutable log of every decision, every tool call, every status change (critical for construction liability)
• Heartbeat scheduling — agents wake up on a schedule, check for work, do their tasks, report results, and go back to sleep

Why Construction Needs This

Construction projects are inherently multi-agent problems. On any commercial job you have estimators, schedulers, procurement specialists, safety officers, document controllers, and project managers — all operating semi-independently but within a shared governance structure.

When you start deploying AI agents for these roles, you immediately hit four problems:

1. Who assigns work? An agent processing RFIs doesn't know a change order just blew up the schedule.
2. Who enforces scope? Without guardrails, an aggressive procurement agent might commit to vendors outside the approved budget.
3. Who tracks the "why"? An audit trail from task to project to company goal is mandatory in construction — if something goes wrong, you need to show exactly what happened and why.
4. Who controls cost? AI usage costs real money (API calls to Claude or GPT-4 cost per token). Without per-agent budgets, costs can spiral fast.

Paperclip solves all four.

Architecture: How Paperclip Maps to a Construction Organization

Here's how Paperclip's structure maps to a typical construction company:

Think of it like this: the Board (you) is the owner. The CEO Agent is your project director — it proposes ideas and delegates, but you have veto power. Below that are managers who own specific domains, and below them are individual contributors (ICs) who do the hands-on work.

In Paperclip's terminology:

Goal Hierarchy: From Punch Item to Company Mission

One of Paperclip's most powerful features for construction is its hierarchical goal system. Every single task an agent works on traces back to a strategic objective — like a chain from the ground floor to the roof.

Quick Start: Spinning Up a Construction Company

Installation

Paperclip requires Node.js 20+. The fastest way to get started:

npx paperclipai onboard --yes

This starts the control plane at http://localhost:3100 with an embedded PostgreSQL database — zero configuration required. No accounts, no pre-installed agents. Just a blank company ready to build.

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

Creating Your Construction Company

Once Paperclip is running, use the CLI or the React-based Board UI to set up your project:

# Create a new company (one per project)
curl -X POST http://localhost:3100/api/companies \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Main St. Commercial Build",
    "mission": "Deliver the Main St. commercial project on time, under budget, with zero safety incidents."
  }'

Hiring Your First Agent

Register a Claude Code-powered Project Manager agent:

# Using the Paperclip CLI
npx paperclipai agent local-cli claudecoder \
  --company-id <company-id> \
  --title "Project Manager" \
  --role manager

Or via the API for a custom agent accessible over HTTP:

curl -X POST http://localhost:3100/api/companies/<company-id>/agents \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ScheduleBot",
    "title": "Scheduling Agent",
    "role": "ic",
    "adapter": "http",
    "adapterConfig": {
      "url": "https://your-scheduling-agent.internal/webhook",
      "method": "POST"
    },
    "capabilities": ["scheduling", "resource-leveling", "critical-path-analysis"],
    "jobDescription": "Maintain the master schedule. Flag float erosion. Propose recovery sequences when delays occur."
  }'

Notice the jobDescription field — this is the agent's "job description" in the org chart. Just like hiring a real employee, you tell the agent what its role is, what it's capable of, and what you expect it to do.

Creating Goals and Tasks

# Set the top-level company goal
curl -X POST http://localhost:3100/api/companies/<company-id>/goals \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Deliver Main St. on time and under budget",
    "description": "Complete by Dec 2026. GMP: $4.2M. Zero lost-time incidents."
  }'
 
# Create a task (issue) linked to the goal
npx paperclipai issue create \
  --company-id <company-id> \
  --title "Process RFI #247: HVAC routing conflict in Zone B" \
  --priority high \
  --assignee <doc-controller-agent-id>

The Heartbeat Protocol: How Agents Actually Do Work

Here's something that surprises people: Paperclip agents don't run continuously. They're not sitting there burning electricity and API credits 24/7. Instead, they wake up on a scheduled heartbeat (like an alarm clock), do their work, report back, and go to sleep.

Each heartbeat automatically injects environment variables so the agent always knows who it is and what it's working on:

# Auto-injected into every agent heartbeat
PAPERCLIP_AGENT_ID=agent_sched_001
PAPERCLIP_COMPANY_ID=comp_mainst
PAPERCLIP_API_URL=http://localhost:3100
PAPERCLIP_API_KEY=pk_live_...
PAPERCLIP_TASK_ID=issue_rfi247
PAPERCLIP_WAKE_REASON=heartbeat

This is how Paperclip integrates with agents like OpenClaw and Hermes — they connect through adapters that translate Paperclip's heartbeat protocol into each agent's native format. For more on how all four tools wire together, see The Agent Stack.

Budget Enforcement: Controlling AI Spend Per Agent

One of the biggest risks of deploying multiple AI agents is runaway costs. Every time an agent calls Claude or GPT-4, it costs money (fractions of a cent per request, but it adds up fast across 10 agents running daily). Paperclip enforces per-agent monthly budgets with two thresholds:

• 80% soft alert — the Board gets notified ("heads up, your estimating agent has used 80% of its monthly budget")
• 100% hard pause — the agent is automatically suspended ("your estimating agent hit its budget cap and is paused until you approve more")

For a construction company running 10 agents, this means you can allocate budgets based on how token-hungry each role is. Estimation agents analyzing 200-page plan sets? $500/month. Safety compliance agent doing mostly yes/no classification? $50/month. The Board sees a single dashboard of spend across all agents — like a cost report for your AI workforce.

For a deeper look at the economics, see From $100K Hires to $100/Month AI Agents.

Governance: The Human in the Loop

Construction is a liability-heavy industry. You absolutely cannot let an AI agent autonomously approve a $200K change order. Paperclip's governance system ensures a human (the Board — that's you) stays in control at all times:

# List pending approvals
npx paperclipai approval list \
  --company-id <company-id> \
  --status pending
 
# Approve a procurement decision
npx paperclipai approval approve <approval-id> \
  --decision-note "Approved. Vendor meets bonding requirements."

For comprehensive security beyond governance — including scanning agent skills for malicious code, detecting prompt injection attacks, and preventing data leakage — see Cisco DefenseClaw. Paperclip handles organizational security (who can do what). DefenseClaw handles technical security (is the code safe? is data leaking?).

Full Example: A 10-Agent Construction Company

Here's what a realistic Paperclip deployment looks like for a mid-sized commercial GC:

Total monthly AI budget: ~$1,875 — less than 2% of what a single junior PM costs annually, running 10 specialized agents 24/7. For a full breakdown of the economics, see From $100K Hires to $100/Month AI Agents.

Multi-Project Support

Paperclip supports multiple Companies on a single instance. For a GC running several projects simultaneously, each project becomes its own isolated company with separate:

• Org charts and agent assignments
• Budgets and cost tracking
• Goal hierarchies
• Audit trails

# Export a proven project setup as a reusable template
npx paperclipai export --template commercial-gc-standard
 
# Spin up a new project from the template
npx paperclipai install cliphub:your-org/commercial-gc-standard

This means when you land a new project, you don't rebuild your agent organization from scratch. You install a template, adjust the goals and budgets, and you're running. Like having a playbook that says "this is our standard crew for a commercial build — plug in the project-specific details and go."

Connecting Paperclip to the Full Agent Stack

Paperclip is the management layer, but it works best when combined with specialized tools for specific capabilities. Here's how it fits into the bigger picture:

For a complete walkthrough of wiring all these together, see The Agent Stack.

When to Use Paperclip vs. Other Tools

Getting Started Today

npx paperclipai onboard --yes

Conclusion

Individual AI agents are powerful. But without an organizational layer — hierarchy, goals, budgets, governance, audit trails — they're just isolated tools doing isolated tasks. It's like having a crew of skilled tradespeople with no superintendent: everyone's capable, but nobody's coordinated.

Paperclip gives construction companies the same control plane that a well-run project team has: clear roles, clear accountability, clear budgets, and a human at the top making the calls that matter. The difference is your "team" costs $2K/month instead of $200K, runs 24/7, and scales with a template install.

The construction industry's next leap isn't building better individual agents. It's building better agent organizations.