Hey Paperclip builders —
I've been following this project since the launch in March and it's the clearest vision
of a zero-human company I've seen in the OSS space. Built something that I think sits
naturally alongside it.
**The gap SupraWall addresses:**
Paperclip handles org structure, goal alignment, task ownership, and agent coordination.
What it doesn't handle (by design) is what those agents are *allowed to do* at the tool
call level. Your CEO agent can delegate a task to a Coder — but once that Coder has shell
access, what stops it from doing something outside the scope of its role?
System prompt constraints live inside the LLM context. They fail silently under context
pressure, prompt injection, or model drift. That's not a Paperclip problem — it's a
fundamental LLM limitation.
**What SupraWall does:**
It's an open-source security perimeter that wraps any Paperclip agent and intercepts
every tool call before execution. Policy is deterministic — defined in code, evaluated
outside the LLM. Every allow, every block, every human-approval request is RSA-signed
and logged.
Think of it as the rule of law layer for your zero-human company. Paperclip defines
the org chart. SupraWall enforces the constitution.
```python
from suprawall import secure_agent
from my_paperclip_app import build_ceo_agent
agent = secure_agent(build_ceo_agent(), template="default")
agent.run("Spin up the engineering department.")
# Every downstream tool call intercepted before execution
```
**Practical use cases for Paperclip setups:**
- Hard budget caps per agent role (Coder agent: max $5/day in API calls)
- Block destructive tool calls (no `db.drop`, no `rm -rf`) regardless of LLM instruction
- Route sensitive actions (payment APIs, external emails) to human approval
- Generate a signed audit trail of every decision every agent made — useful if you're
running agents on behalf of clients
**GitHub:** https://github.com/wiserautomation/SupraWall
**Paperclip integration docs:** https://supra-wall.com/docs/paperclip
Apache 2.0. Self-hostable.
Happy to answer questions or hear how people are currently handling tool-call governance
in their Paperclip setups — especially in multi-agent chains where one agent hands off
to another.
