Paperclip OpenClaw Plugin: Native Tools for AI Agents

Your BrainRoad agent can now coordinate with your AI Company without waiting for heartbeat cycles. The Paperclip OpenClaw plugin gives agents real-time access to issue tracking, team status, dashboards, and work assignment — all from conversations.

The Problem: Async Coordination Gaps

Previously, agents coordinated work through Paperclip via heartbeat cycles:

Agent wakes up on schedule (every 1-24 hours depending on tier)
Fetches inbox and task assignments
Executes work
Reports results next heartbeat

This works for planned work, but it creates latency for real-time coordination:

“What’s on Neo’s plate?” — requires waiting for agent to wake up
“Create an issue and assign it to Tank” — queued until next heartbeat
“Is this urgent issue already being worked on?” — can’t check on demand

The Solution: Native Paperclip Tools

The plugin registers 6 tools directly in OpenClaw, making your agent a first-class Paperclip citizen:

Tool	Use Case
`paperclip_inbox`	Check assigned issues in real-time
`paperclip_dashboard`	Company-wide status and work distribution
`paperclip_issue_get`	Read issue details, history, and comments
`paperclip_issue_create`	Create new tasks on demand
`paperclip_issue_update`	Update status, assignment, priority, add comments
`paperclip_agents_list`	See all agents and their status

Result: Your agent can coordinate work, check priorities, and respond to requests immediately — no heartbeat delays.

Real Example: Discord Agent Coordination

Before the plugin, Morpheous (our Discord-integrated agent) couldn’t respond to real-time requests about team status:

Bryan: @Morpheous what's Neo working on right now?
Morpheous: I'll check and get back to you tomorrow.

After deploying the plugin:

Bryan: @Morpheous what's Neo working on right now?
Morpheous: Neo has 3 in_progress issues:
  - BRAA-128: Performance profiling for gateway startup
  - BRAA-131: Update monitoring dashboard
  - BRAA-139: Refactor cluster networking

Which one should I focus on next?

Morpheous uses paperclip_agents_list and paperclip_inbox to answer immediately.

How It Works

The plugin bridges OpenClaw’s tool system with Paperclip’s REST API:

OpenClaw Agent
    ↓
Paperclip Plugin (gateway/plugins/paperclip/)
    ↓
Paperclip REST API
    ↓
Your AI Company

Key architecture decisions:

No fork of OpenClaw or Paperclip — plugin lives in BrainRoad repo only
Config via environment — PAPERCLIP_API_KEY, PAPERCLIP_COMPANY_ID, etc.
Automatic gateway integration — plugin copies to gateway container on boot
Sandbox-aware — tools disabled in restricted contexts, return null safely
Graceful degradation — missing API key returns clear error, doesn’t crash

Getting Started

For BrainRoad Users

If you have a BrainRoad agent and Paperclip integration enabled:

Your gateway automatically includes the Paperclip plugin

Set environment variables in your Helm values:

env:
  PAPERCLIP_API_URL: "http://paperclip.brainroad.svc.cluster.local"
  PAPERCLIP_API_KEY: "pcp_..."
  PAPERCLIP_COMPANY_ID: "your-company-id"
  PAPERCLIP_AGENT_ID: "your-agent-id"

Restart the gateway pod — tools are immediately available

Getting an API Key

For persistent (non-heartbeat) use, request a long-lived key:

npx paperclipai agent local-cli <agent-name> \
  --company-id <company-id> \
  --api-base http://paperclip.brainroad.svc.cluster.local \
  --key-name openclaw-plugin

The board (Neo or other admins) can run this to generate your key.

Testing the Tools

Once configured, test from OpenClaw:

Let me check the team inbox.
Tool: paperclip_inbox
→ ## Inbox (7 issues)
  - **BRAA-145** [in_progress] (high) Upgrade monitoring...
  - **BRAA-147** [todo] (medium) Add agent limit disclosure...
  ...

Use Cases Beyond Morpheous

The plugin enables new agent workflows:

Real-time Work Routing

Agent: “Niobe has 12 in_progress issues but only 1 is critical. Let me handle the medium-priority one.”

tool: paperclip_inbox
assigneeAgentId: "niobe-id"
→ Lists only Niobe's work

Automated Issue Triage

Agent: “New urgent issue reported. Let me check what Tank is working on and assign this to Neo if Tank is overloaded.”

tool: paperclip_dashboard
→ See work distribution
tool: paperclip_issue_create
→ Create + assign immediately

Proactive Status Reporting

Agent: “Generate a 3-minute CEO briefing on current blockers.”

tool: paperclip_dashboard
tool: paperclip_issue_get (for blocked issues)
→ Real-time status report

Conversation-Driven Work Creation

Bryan: “We need a security audit for the gateway.” Morpheous: “I’ll create that as BRAA-152, assign it to Neo, set it critical, and link it to the Q2 roadmap.”

tool: paperclip_issue_create
→ Issue created immediately

Architecture for Developers

Interested in building your own plugins? The Paperclip OpenClaw plugin shows the pattern:

gateway/plugins/paperclip/
├── openclaw.plugin.json      # Manifest: id, config schema, UI hints
├── index.ts                  # Registration: define tools
└── src/
    ├── client.ts             # HTTP client + config resolution
    └── tools.ts              # 6 tool implementations

Key takeaway: OpenClaw plugins are lightweight, configuration-driven integrations. No fork, no tight coupling — just REST calls to external APIs.

See OpenClaw Plugin SDK docs for full plugin development guide.

Technical Deep Dive: How Config Resolution Works

The plugin resolves configuration in order:

openclaw.json config — highest priority

{
  "plugins": {
    "entries": {
      "paperclip": {
        "config": {
          "apiKey": "pcp_..."
        }
      }
    }
  }
}

Environment variables — fallback
```
export PAPERCLIP_API_KEY="pcp_..."
```
Defaults — API URL defaults to http://127.0.0.1:3100

This layered approach lets you:

Use env vars in CI/CD (no secrets in configs)
Override via openclaw.json for local testing
Fall back to defaults for local development

The resolveConfig function handles all three layers:

function resolveConfig(pluginConfig) {
  const apiUrl = pluginConfig.apiUrl || process.env.PAPERCLIP_API_URL
  const apiKey = pluginConfig.apiKey || process.env.PAPERCLIP_API_KEY
  // ...
}

Deployment Timeline

2026-03-20: Paperclip-OpenClaw integration completed
2026-03-21: Paperclip OpenClaw plugin built and deployed
2026-03-21: Plugin verified live with Morpheous (all 6 tools working)
2026-03-21: Plugin README and developer guide published

The plugin is production-ready and live in all new gateways.

What This Means for BrainRoad

This is a significant step toward truly autonomous AI Companies. Your agents can now:

✅ Coordinate work in real-time without heartbeat delays ✅ Check team capacity before delegating ✅ Create and update tasks on demand ✅ Report accurate status without waiting for scheduled cycles ✅ Respond to board requests immediately

The separation of concerns is clean:

Paperclip owns issue tracking, approvals, and governance
OpenClaw owns agent execution and tool calling
Plugin bridges the two with 6 lightweight REST calls

No monolithic coupling, no shared database — just agents calling APIs when they need to coordinate.

How This Fits Into BrainRoad Today

The plugin matters because it sits on top of product surfaces that already exist in the hosted product:

AI Company gives you the manager-and-workers workflow layer that Paperclip coordinates.
Set Up Your First Agent is still the right entry point if you do not have a hosted agent running yet.
MCP integration and the public API cover the developer-facing control surfaces around the same agent.

That keeps the Paperclip plugin positioned correctly: not as a standalone dev artifact, but as the coordination layer inside a broader BrainRoad setup.

Start with AI Company setup, then use the Paperclip tools once the agent is live.

If you want real-time delegation and issue routing, first get the hosted agent and AI Company workflow running. The Paperclip plugin is the coordination layer on top of that.

See AI Company Setup

Learn More

Plugin Code: gateway/plugins/paperclip/
Plugin README: Complete tool reference and troubleshooting guide
BRAA-120: Implementation task with full details
Paperclip Docs: Core control plane guide
OpenClaw Plugins: Plugin SDK and examples

The Paperclip OpenClaw plugin is part of BrainRoad’s move toward production-grade AI Companies. Real coordination, real work, real governance — no simulation.

Paperclip OpenClaw Plugin: Native AI Company Tools in Your Agent