At Sparkwave we are building a near-autonomous AI agent business.
Our agents create digital products, run information services, conduct research, write content, run marketing and social media, and drive sales. Each agent has a defined role and responsibilities, similar to a small team inside a company.
Today our system runs six OpenClaw agents coordinated through Paperclip:
Rico, Dev, Iris, Jerry, Arlo, and Opal.
This article explains the communication and orchestration model that allows them to assign work, request information from each other, and operate as a functioning team.
The Core Problem
Agents may be very capable individually, but once multiple agents are running across servers a new set of operational questions appears:
-
How do agents assign work to each other?
-
How do they ask each other for information?
-
How do they know when something is finished?
-
How do they avoid waiting on a human?
Our agents run on separate servers and do not share memory or runtime context.
So coordination has to be explicit.
The solution we use is simple and strict:
Paperclip for coordination, polling for discovery, and wakeups for urgency.
The Core Principle
Paperclip is the single source of truth for coordination.
Every interaction between agents happens through Paperclip issues and their comment threads.
An issue can represent either:
In other words:
communication happens through issues.
If Rico needs information from Arlo, Rico does not message Arlo directly.
Rico creates a Paperclip issue.
Example:
Title: Research Request — Market sentiment on AI video tools
Assigned to: Arlo
Description:
Please gather current signals from X, Reddit, and product launches
about AI video generation tools.
Output format:
- 5 key trends
- notable startups
- sentiment summary
- sources
Arlo detects the issue through its polling loop and begins work.
If clarification is required, Arlo asks the question in the issue comments:
Arlo (comment)
Acknowledged. Starting research.
Clarification:
Should this focus only on developer-oriented generation tools
(Runway, Pika, etc.), or include editing tools and avatar platforms?
Rico replies in the same thread:
Rico (comment)
Focus on developer-oriented generation tools.
Exclude editing and avatar platforms.
Arlo completes the research and posts the results in the same issue.
The issue provides the context.
The comments provide the conversation.
Why This Matters
Without a structured coordination layer, multi-agent systems quickly drift into confusion:
-
agents waiting for messages
-
humans relaying instructions
-
work getting lost
-
nobody knowing if something started
The rule we adopted is simple:
If it isn't in Paperclip, it doesn't exist.
Even when I communicate with agents through other channels.
For example, I might message Rico through Telegram while on my phone.
Rico still converts that instruction into a Paperclip issue before work begins.
That keeps the entire system synchronized.
Layer 1 — Paperclip as the Coordination Layer
Paperclip acts as the orchestration layer for the agent organization.
Agents do not communicate through direct messages.
They communicate through issues and comments.
This creates:
-
persistent records
-
clear assignment
-
shared visibility
-
system observability
The issue becomes the shared workspace for the interaction.
Layer 2 — Polling: How Agents Discover Work
Each agent runs a polling loop.
Every few minutes the agent checks Paperclip for issues assigned to it.
Example cron configuration:
Design choices
openclaw cron add paperclip-poll \
--schedule "every 10m" \
--session isolated \
--model haiku \
--message "
Check Paperclip for issues assigned to you.
If open issues exist:
1. Select the highest priority issue
2. Post a comment acknowledging it
3. Complete the requested work
4. Post results as a comment
5. Mark the issue done
Repeat until no open issues remain.
"
Small model for polling
Polling happens frequently, so it uses a lightweight model.
If work is required, the agent escalates to a larger model.
Isolated sessions
Each poll runs in a clean session.
No context leaks between tasks.
Layer 3 — Wakeups for Urgent Work
Polling introduces a small delay.
If agents check every 10 minutes, a new issue may wait a few minutes before it is detected.
That is acceptable for most work.
But occasionally we want immediate execution.
Examples:
-
production issues
-
time-sensitive research
-
cross-agent handoffs
In those cases we trigger an agent wakeup:
node /root/clawd/scripts/wakeup-agent.mjs <agent_name> "reason" <issue_id>
This sends a direct HTTP request to the agent gateway.
The wakeup does not contain the task.
It simply tells the agent:
Check Paperclip now.
The issue always remains the source of truth.
The Acknowledgment Protocol
One small rule dramatically improved reliability.
When an agent picks up an issue, it immediately posts an acknowledgment comment.
Example:
Acknowledged: Research Request — Market sentiment on AI video tools.
Starting analysis now.
This closes the loop.
Without it, you cannot tell whether:
Verification Before Reporting Completion
Another rule:
Completion must be verifiable.
Example development workflow.
Dev:
- implement change
- commit and push
- post commit hash in Paperclip
- mark issue done
Rico:
- verify commit exists in repo
- confirm change matches specification
- only then report completion
Agents do not rely on claims of completion.
They verify.
Cross-Agent Coordination
Sometimes an agent starts work and realizes it needs information from another agent.
In that situation the agent creates another Paperclip issue assigned to the appropriate teammate.
Example workflow:
Rico → creates research issue → Arlo
Arlo begins research
Arlo realizes internal metrics are needed
Arlo → creates new issue → Jerry
"Data Request — Signup metrics"
Jerry responds with the data
Arlo incorporates the data
Arlo finishes the research issue
This allows agents to coordinate work dynamically without human intervention.
Communication Between Agents
Many agent systems overlook this point:
Agents must be able to ask each other questions.
For example:
Title: Data Request — User signup metrics
Assigned to: Jerry
Please provide:
- signups last 7 days
- signups last 30 days
- growth rate
Jerry replies with the numbers in the issue comments.
That pattern allows agents to request information from teammates instead of relying on humans.
What Didn't Work
Several approaches failed quickly.
Messaging apps for agent coordination
Telegram works well for human → agent interaction.
It is unreliable for agent → agent coordination.
Humans relaying instructions
If a human is forwarding messages between agents, the system is broken.
Assuming a wakeup worked
Always verify work through Paperclip comments or artifacts.
Why This Architecture Works
Three properties make the system reliable.
One source of truth
All coordination lives in Paperclip issues.
Stateless agents
Polling avoids reliance on shared memory or persistent sessions.
System visibility
Every step appears in the issue thread.
The Bigger Goal
Sparkwave Digital is designed to operate as a near-autonomous AI business.
That requires agents that can:
-
assign work
-
request information
-
verify outcomes
-
recover from failures
Once those capabilities exist, the agents begin to function like a coordinated team rather than isolated tools.
Orchestration becomes the foundation for autonomy.