# Paperclip for Claude Code: what it does and how to install it

> Paperclip is an open source Node.js server and React UI that orchestrates a team of AI agents to run a business. Flowy indexes 22 components for it: 14 skills and 8 agents covering task coordination, agent hiring, a cited company wiki, and cross-session memory. It suits a team running Paperclip as its agent operations layer, not a single coding task.

Canonical: https://www.flowy.sh/plugins/paperclipai-paperclip/guide
Published: 2026-10-29
Updated: 2026-10-29
Author: Flowy

## What is Paperclip?

Paperclip, indexed from `paperclipai/paperclip`, is an open source Node.js
server and React UI that orchestrates a team of AI agents to run a business,
not just to finish a coding task. The project frames its own scope directly:
if a tool like OpenClaw is one AI employee, Paperclip is the company built
around it, the control plane that hires agents and tracks their work. Flowy
indexes 22 components for it: 14 skills and 8 agents, filed under automation.

Flowy indexes this plugin from its public repository. It does not host,
modify, or bundle the code. The install command lives on [the install card on the listing page](https://www.flowy.sh/listings/paperclipai-paperclip#install).

## How do the control plane skills run a company?

Five skills form the part of Paperclip you talk to directly. `paperclip` is
the base skill for the control plane API itself: checking assignments,
updating issue status, posting comments, delegating work, managing routines,
and calling Paperclip endpoints. `paperclip-board` sits above that, built
for chat rather than raw API calls, for a board member who needs onboarding,
company or agent management, approvals, task monitoring, cost oversight, or
work product review.

Two skills turn intent into assigned work. `paperclip-converting-plans-to-tasks`
breaks a Paperclip plan into an executable issue graph, working out
specialty fit, dependencies, blockers, and what can run in parallel.
`paperclip-create-agent` handles hiring: it inspects adapter configuration
options, compares existing agent configs, drafts a new agent prompt or
config, and submits a hire request, with governance built in rather than a
plain create call.

The fifth, `paperclip-task-bridge`, lets a separate assistant called Hermes
create, comment on, update, and list Paperclip tasks using scoped Paperclip
API credentials, for when work needs to start outside Paperclip's own chat
surface.

## What do the LLM Wiki skills do in Paperclip?

Six skills maintain what the project calls the LLM Wiki, a cited local
company wiki meant to outlast any single chat session. `wiki-maintainer` is
the entry point for using its tools day to day. `wiki-ingest` turns a
captured raw source into durable source, entity, concept, synthesis, index,
and log pages. `paperclip-distill` does the same job for Paperclip's own
activity, turning a cursor window or backfill of task history into
standups, project pages, decisions, and history, without dereferencing
assets. `wiki-query` answers a question from wiki pages and raw sources
with citations, names gaps plainly, and can offer to file new synthesis
when the answer is worth keeping. `wiki-lint` audits for contradictions,
orphans, weak sourcing, broken links, missing concept pages, and index or
log drift, and only reports what it finds. `index-refresh` rebuilds the
index from the actual page tree and reconciles missing or deleted entries,
without editing page bodies itself.

## Which Paperclip components handle memory, design, and content?

`para-memory-files` is a separate, file based memory system built on the
PARA method: storing and recalling facts, daily notes, entity records,
weekly syntheses, and user patterns across sessions, apart from the wiki.
`design-guide` documents Paperclip's own UI design system, for creating or
modifying UI components, adding pages to the frontend, styling elements, or
understanding the design language the product follows. `content-calendar`
looks outward instead: it plans a weekly editorial calendar by mapping
company goals to publishable topics, owners, status, and verification notes.

## What do the 8 agents do in Paperclip?

Four agents are hiring templates rather than agents you run yourself.
`coder`, `qa`, `securityengineer`, and `uxdesigner` describe the role a new
hire should fill (implementing and testing code, reproducing bugs and
validating fixes, owning security posture, or producing UX specs and
reviewing interface quality) for `paperclip-create-agent` to read, not for
calling directly.

The other four are narrow, bounded sweeps. `token-auditor` scans the UI
source for hardcoded visual values, duplicate components, and shadcn
replacement candidates, and only reads, never touching component files.
`codemod-runner` is its follow-up: once that audit exists, it writes and
runs the codemod scripts that replace the hardcoded values with token
references, doing mechanical refactors only. `recent-agent-reflection` runs
a bounded review of recently active agents and produces coaching proposals
only, never changing another agent's live instructions without an accepted
task interaction. `refresh-stale-summaries` is paused by default and spends
nothing until an operator enables its schedule or runs it by hand; when it
runs, it only regenerates summary slots whose scope has changed, and never
mutates issues, workspaces, or code.

## Who should use Paperclip?

This is not a plugin for adding one skill to an existing coding session. Its
22 components assume a company-shaped structure: a board skill for
oversight, a task bridge for outside tools, hiring templates, a cited wiki,
and PARA memory so decisions survive between sessions, plus a pair of
bounded agents that keep the UI's own source clean. It fits a team running
Paperclip as its agent operations layer, not a developer wanting one extra
skill.

Sources: [paperclipai/paperclip on GitHub](https://github.com/paperclipai/paperclip), [paperclipai/paperclip README](https://github.com/paperclipai/paperclip#readme)

## Common questions

### What is the Paperclip plugin for Claude Code?

Paperclip is indexed from `paperclipai/paperclip`, an open source Node.js server and React UI for orchestrating a team of AI agents that run a business rather than just write code. Flowy indexes 22 components for it: 14 skills and 8 agents, filed under automation. It covers task coordination, agent hiring, a cited company wiki, and cross-session memory.

### What is the difference between the paperclip and paperclip-board skills?

`paperclip` is the base skill for calling the Paperclip control plane API directly: checking assignments, updating issue status, posting comments, delegating work, and managing routines. `paperclip-board` is built for chat instead, for someone acting as a board member who needs onboarding, company or agent management, approvals, task monitoring, cost oversight, and work product review.

### What does the LLM Wiki do in Paperclip?

The LLM Wiki is a cited local company wiki maintained by six skills. `wiki-ingest` turns a captured source into durable pages, `paperclip-distill` does the same for Paperclip's own task activity, `wiki-query` answers questions from existing pages with citations, `wiki-lint` audits for contradictions and drift without fixing them, and `index-refresh` rebuilds the wiki's index from the actual page tree. `wiki-maintainer` is the entry point for using these tools day to day.

### Does Paperclip include templates for hiring agents?

Yes. Four of its eight agents are hiring templates read by the `paperclip-create-agent` skill rather than run directly: `coder` for engineers who implement and test code, `qa` for engineers who reproduce bugs and validate fixes, `securityengineer` for someone who owns security posture, and `uxdesigner` for someone who produces UX specs and reviews interface quality.

### What do the token-auditor and codemod-runner agents do?

They run a two phase design cleanup on Paperclip's own frontend. `token-auditor` scans the UI source for hardcoded visual values, duplicate components, and shadcn replacement candidates, and only reads, it never modifies component files. `codemod-runner` is phase two: once that audit exists, it writes and runs the codemod scripts that replace those hardcoded values with token references, doing mechanical refactors only.

## Related

- [The listing page](https://www.flowy.sh/listings/paperclipai-paperclip): Install command, components and repository
- [Alternatives to this plugin](https://www.flowy.sh/alternatives/paperclipai-paperclip): Peers in its category, ranked by stars
- [The Claude Code plugin marketplace](https://www.flowy.sh/marketplace/plugins): How plugins install, and every plugin in the index
- [Archon for Claude Code: what it does and how to install it](https://www.flowy.sh/plugins/coleam00-archon/guide): another plugin guide
- [superpowers for Claude Code: what it does and how to install it](https://www.flowy.sh/plugins/superpowers-flow/guide): another plugin guide