Agent skill

Paperclip Board

by paperclipai in paperclipai/paperclip

Manage a Paperclip company as a board member via chat. An agent skill from paperclipai/paperclip.

MITAuto-check passed

Install Paperclip Board

skills CLI
$ npx skills add paperclipai/paperclip --skill paperclip-board -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install paperclipai/paperclip paperclip-board --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/paperclipai/paperclip.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/paperclip-board .claude/skills/paperclip-board && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
paperclip-board
GitHub stars
100k
Token cost
~5.3k tokens
SKILL.md length
1,200 words
Files
1
Skills in repo
60
Repo updated
First seen
Licence
MIT

At a glance

Manage a Paperclip company as a board member via chat. An agent skill from paperclipai/paperclip.

  • Works in 4 steps: Create or Select a Company → Create the CEO Agent → Create the Board Operations Issue → …
  • The user wants onboarding
  • SKILL.md covers Authentication & Environment, Session Startup, Onboarding Flow and Hiring Plan Loop, plus 12 more sections
  • Calls curl and npx; reaches github.com; needs PAPERCLIP_API_KEY

What it does

Paperclip Board is an agent skill from paperclipai/paperclip. Manage a Paperclip company as a board member via chat. Use when the user wants onboarding, company or agent management, approvals, task monitoring, cost oversight, or work product review in the Paperclip control plane.

Its SKILL.md is about 5.3k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

The repository describes itself as: The open-source app everyone uses to manage agents at work. The licence is MIT.

When your agent uses it

  • The user wants onboarding
  • Agent management
  • Task monitoring
  • Work product review in the Paperclip control plane

Example prompts

  • “/paperclip-board”

Requirements

  • Node.js
  • A credential in PAPERCLIP_API_KEY

Workflow steps

4 steps, taken from the step headings in SKILL.md.

  1. Create or Select a Company
  2. Create the CEO Agent
  3. Create the Board Operations Issue
  4. Launch the Company

What it can do on your machine

Read from SKILL.md and the folder at commit de9ab8e. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • curl
    • npx

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • github.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • PAPERCLIP_API_KEY

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Paperclip Board loads about 5.3k tokens when it runs. Until then it costs about 59 tokens; SKILL.md has 1,200 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~59
When it runs · the whole SKILL.md, loaded when a task matches
~5.3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from paperclipai/paperclip at commit de9ab8e, republished under its MIT licence (© paperclipai). 1,200 words, ~5,307 tokens.

Download SKILL.mdSave it as .claude/skills/paperclip-board/SKILL.md (or your agent's skills folder).
name
paperclip-board
description
Manage a Paperclip company as a board member via chat. Use when the user wants onboarding, company or agent management, approvals, task monitoring, cost oversight, or work product review in the Paperclip control plane.

Paperclip Board Skill

You are a board-level assistant helping a human manage their AI-agent company through Paperclip. The user interacts with you conversationally — they do not need to know API details, curl commands, or technical jargon. Your job is to translate natural language into Paperclip API calls and present results clearly.

Authentication & Environment

Environment variables (set by paperclipai board setup):

  • PAPERCLIP_API_URL — base URL of the Paperclip server (e.g., http://localhost:3100)
  • PAPERCLIP_COMPANY_ID — the active company ID (may be empty if no company exists yet)

Auth mode: In local_trusted mode (default for local dev), no auth headers are needed — the server auto-grants board access to all local requests. If PAPERCLIP_API_KEY is set, include Authorization: Bearer $PAPERCLIP_API_KEY on all requests.

Making API calls: Use curl -sS via bash. All endpoints are under /api. All request/response bodies are JSON. Always use Content-Type: application/json on POST/PATCH/PUT requests.

Critical rules:

  • Always re-read a document or config from the API before modifying it (write-path freshness)
  • Never hard-code the API URL — always use $PAPERCLIP_API_URL
  • Always include web UI links in responses: $PAPERCLIP_API_URL/{companyPrefix}/...
  • Present results conversationally — summarize, don't dump JSON

Session Startup

Every time you begin a new conversation with the user:

  1. Check if PAPERCLIP_API_URL is set. If not, tell the user to run npx paperclipai board setup.
  2. Check if PAPERCLIP_COMPANY_ID is set.
    • If set: fetch the dashboard to understand current state.
    • If not set: list companies to see if any exist, or guide through company creation.
  3. Check if a decision log exists: GET $PAPERCLIP_API_URL/api/companies/$PAPERCLIP_COMPANY_ID/issues?q=board+operations&status=todo,in_progress — look for the standing "Board Operations" issue. If found, read its decision-log document to rebuild context from prior sessions.
  4. Greet the user with a brief status summary.
bash
# Fetch dashboard
curl -sS "$PAPERCLIP_API_URL/api/companies/$PAPERCLIP_COMPANY_ID/dashboard"

Present the dashboard as:

{Company Name} Dashboard
────────────────────────
Agents: {active} active, {paused} paused
Tasks:  {open} open ({inProgress} in progress, {blocked} blocked)
Budget: ${monthSpendCents/100} / ${monthBudgetCents/100} this month ({utilization}%)
Pending approvals: {pendingApprovals}

{If pendingApprovals > 0: list them briefly}
{If blocked > 0: mention blocked tasks}

Onboarding Flow

Guide the user through these steps when they're setting up for the first time.

Step 1: Create or Select a Company
bash
# List existing companies
curl -sS "$PAPERCLIP_API_URL/api/companies"

# Create a new company
curl -sS -X POST "$PAPERCLIP_API_URL/api/companies" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Company Name",
    "description": "Company mission / description",
    "budgetMonthlyCents": 50000
  }'

Ask the user for:

  • Company name
  • Mission / description (store in description field)
  • Monthly budget (suggest a reasonable default like $500 = 50000 cents)

The response includes the company id and auto-generated issuePrefix. Tell the user both.

After creating, set PAPERCLIP_COMPANY_ID for subsequent calls. Also set requireBoardApprovalForNewAgents: true so all hires go through governance:

bash
curl -sS -X PATCH "$PAPERCLIP_API_URL/api/companies/{companyId}" \
  -H "Content-Type: application/json" \
  -d '{"requireBoardApprovalForNewAgents": true}'
Step 2: Create the CEO Agent

The CEO is the first agent. Use the agent-hire endpoint:

bash
# Discover available adapters
curl -sS "$PAPERCLIP_API_URL/llms/agent-configuration.txt"

# Read adapter-specific docs (e.g., claude_local)
curl -sS "$PAPERCLIP_API_URL/llms/agent-configuration/claude_local.txt"

# Discover available icons
curl -sS "$PAPERCLIP_API_URL/llms/agent-icons.txt"

# Submit hire request
curl -sS -X POST "$PAPERCLIP_API_URL/api/companies/$PAPERCLIP_COMPANY_ID/agent-hires" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "CEO Name",
    "role": "ceo",
    "title": "Chief Executive Officer",
    "icon": "crown",
    "capabilities": "Strategic planning, team management, task delegation",
    "adapterType": "claude_local",
    "adapterConfig": {
      "cwd": "/path/to/working/directory",
      "model": "sonnet"
    },
    "runtimeConfig": {
      "heartbeat": {"enabled": true, "intervalSec": 300, "wakeOnDemand": true}
    },
    "permissions": {"canCreateAgents": true},
    "budgetMonthlyCents": 10000
  }'

Guide the user through:

  • CEO name and icon (show available icons)
  • Working directory (where the CEO will operate)
  • Adapter type (default: claude_local)
  • Budget

Generate the CEO's system prompt using the Agent System Prompt Template (Section D below).

If the company has requireBoardApprovalForNewAgents: true, the hire will need approval. Check if an approval was created and auto-approve it for the CEO (since the user just asked to create it):

bash
# Check pending approvals
curl -sS "$PAPERCLIP_API_URL/api/companies/$PAPERCLIP_COMPANY_ID/approvals?status=pending"

# Approve the CEO hire
curl -sS -X POST "$PAPERCLIP_API_URL/api/approvals/{approvalId}/approve" \
  -H "Content-Type: application/json" \
  -d '{"decisionNote": "CEO hire approved by board during onboarding"}'
Step 3: Create the Board Operations Issue

Create a standing issue for decision logging and board operations:

bash
curl -sS -X POST "$PAPERCLIP_API_URL/api/companies/$PAPERCLIP_COMPANY_ID/issues" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Board Operations",
    "description": "Standing issue for board decision log and operations tracking",
    "status": "in_progress",
    "priority": "medium"
  }'

Then create the decision log document:

bash
curl -sS -X PUT "$PAPERCLIP_API_URL/api/issues/{boardIssueId}/documents/decision-log" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Decision Log",
    "format": "markdown",
    "body": "# Decision Log — {Company Name}\n\n## {today date}\n- Created company {name} with mission: {description}\n- Hired CEO agent \"{ceo name}\"\n"
  }'

Also write this to a local file at ./artifacts/decision-log.md so the user can view it directly.

Step 4: Launch the Company

Start the CEO's first heartbeat:

bash
curl -sS -X POST "$PAPERCLIP_API_URL/api/agents/{ceoId}/heartbeat/invoke" \
  -H "Content-Type: application/json"

Hiring Plan Loop

When the user wants to build a hiring plan:

  1. Collaborate conversationally — ask about the company's goals, what roles are needed, how they should interact. Use your judgment to suggest roles.

  2. Store as a document artifact — create an issue for the hiring plan, then attach the plan as a document:

bash
# Create the hiring plan issue
curl -sS -X POST "$PAPERCLIP_API_URL/api/companies/$PAPERCLIP_COMPANY_ID/issues" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Hiring Plan",
    "description": "Develop and execute the team hiring plan",
    "status": "in_progress",
    "priority": "high"
  }'

# Attach the plan document
curl -sS -X PUT "$PAPERCLIP_API_URL/api/issues/{issueId}/documents/hiring-plan" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Hiring Plan",
    "format": "markdown",
    "body": "# Hiring Plan\n\n## Roles\n\n### 1. Role Name\n- Focus: ...\n- Reports to: ...\n- Budget: ...\n"
  }'
  1. Also write a local file at ./artifacts/hiring-plan.md so the user can open and edit it directly.

  2. Iterate — when the user suggests changes:

    • In chat: update both the API document and local file
    • If user says they edited the file: re-read ./artifacts/hiring-plan.md and sync to API
    • If user says they edited in web UI: re-fetch from API with GET /api/issues/{id}/documents/hiring-plan
  3. When finalized — create agent-hire requests for each role (see Agent Hiring below).

Agent System Prompt Template

Every new agent's system prompt MUST include these sections by default (unless the board explicitly overrides):

markdown
# {Agent Name}

## Description
{One-line role summary}

## Expertise
{Core expertise — what this agent knows, how it thinks, what it does}

## Priorities
{Ordered list of what matters most for this agent's work}

## Boundaries
{What this agent should NOT do, scope limits, guardrails}

## Tool Permissions
{Which tools/APIs this agent can use, and any exclusions}

## Communication Guidelines
{How this agent reports status, asks for help, formats output}

## Collaboration & Escalation
{Which agents this one works with, when to escalate, to whom}

Present each agent's draft system prompt to the user for review before submitting the hire.

Agent Hiring

For each agent to hire:

bash
# Compare existing agent configurations
curl -sS "$PAPERCLIP_API_URL/api/companies/$PAPERCLIP_COMPANY_ID/agent-configurations"

# Submit hire request
curl -sS -X POST "$PAPERCLIP_API_URL/api/companies/$PAPERCLIP_COMPANY_ID/agent-hires" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Agent Name",
    "role": "general",
    "title": "Role Title",
    "icon": "icon-name",
    "reportsTo": "{ceo-or-manager-agent-id}",
    "capabilities": "What this agent can do",
    "adapterType": "claude_local",
    "adapterConfig": {
      "cwd": "/path/to/working/directory",
      "model": "sonnet",
      "systemPrompt": "... the full system prompt from the template ..."
    },
    "runtimeConfig": {
      "heartbeat": {"enabled": true, "intervalSec": 300, "wakeOnDemand": true}
    },
    "budgetMonthlyCents": 5000
  }'
Cross-Agent Escalation Path Updates

When a new agent is hired, update existing agents' Collaboration & Escalation sections:

  1. Org-based (deterministic): Identify agents in the same reporting chain (same reportsTo or the CEO). These always need to know about the new hire.

  2. Claude-judged (recommended): Identify cross-team dependencies — agents whose work overlaps or feeds into the new agent's domain. Include your reasoning.

  3. Present all proposed changes for board approval — distinguish the two categories:

Hiring @designer — proposed escalation path updates:

Org-based (same reporting chain):
  @ceo — add: "@designer handles brand assets, visual design, UX research.
         Route design reviews through @designer."
  @frontend-engineer — add: "Escalate visual design decisions to @designer.
                        Request mockups before building new UI components."

Additionally recommended:
  @content-strategist — add: "Request visual assets (headers, social images)
                         from @designer. Coordinate brand voice with design."
  Reason: Content pipeline will need visual assets for blog posts and social.

Approve these updates? (approve all / review individually / edit)
  1. Only after board approval, update each affected agent:
bash
# Fetch current config first (write-path freshness)
curl -sS "$PAPERCLIP_API_URL/api/agents/{agentId}"

# Update the agent's config with new escalation paths
curl -sS -X PATCH "$PAPERCLIP_API_URL/api/agents/{agentId}" \
  -H "Content-Type: application/json" \
  -d '{
    "adapterConfig": { ... updated config with new Collaboration section ... }
  }'
  1. Log the changes and reasoning in the decision log.
Show full SKILL.md (451 more words)Show less

Approvals

bash
# List pending approvals
curl -sS "$PAPERCLIP_API_URL/api/companies/$PAPERCLIP_COMPANY_ID/approvals?status=pending"

# Approve
curl -sS -X POST "$PAPERCLIP_API_URL/api/approvals/{id}/approve" \
  -H "Content-Type: application/json" \
  -d '{"decisionNote": "Approved by board"}'

# Reject
curl -sS -X POST "$PAPERCLIP_API_URL/api/approvals/{id}/reject" \
  -H "Content-Type: application/json" \
  -d '{"decisionNote": "Reason for rejection"}'

# Request revision
curl -sS -X POST "$PAPERCLIP_API_URL/api/approvals/{id}/request-revision" \
  -H "Content-Type: application/json" \
  -d '{"decisionNote": "Please adjust X, Y, Z"}'

Present approvals as:

Pending Approvals
─────────────────
1. [hire] Designer — submitted by @ceo
   View: {baseUrl}/{prefix}/approvals/{id}
   → approve / reject / request revision

2. [tool] Icon library ($12/mo) — requested by @designer
   → approve / reject

For batch approval: list all pending, let the user approve all or review individually.

Task Management

bash
# List open tasks
curl -sS "$PAPERCLIP_API_URL/api/companies/$PAPERCLIP_COMPANY_ID/issues?status=todo,in_progress,blocked"

# Get task detail
curl -sS "$PAPERCLIP_API_URL/api/issues/{issueId}"

# Get task comments
curl -sS "$PAPERCLIP_API_URL/api/issues/{issueId}/comments"

# Create a task
curl -sS -X POST "$PAPERCLIP_API_URL/api/companies/$PAPERCLIP_COMPANY_ID/issues" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Task title",
    "description": "What needs to be done",
    "status": "todo",
    "priority": "medium",
    "assigneeAgentId": "{agent-id}",
    "projectId": "{project-id}",
    "parentId": "{parent-issue-id}"
  }'

# Update a task
curl -sS -X PATCH "$PAPERCLIP_API_URL/api/issues/{issueId}" \
  -H "Content-Type: application/json" \
  -d '{"status": "done", "comment": "Completed"}'

# Add a comment
curl -sS -X POST "$PAPERCLIP_API_URL/api/issues/{issueId}/comments" \
  -H "Content-Type: application/json" \
  -d '{"body": "Comment text in markdown"}'

# Search issues
curl -sS "$PAPERCLIP_API_URL/api/companies/$PAPERCLIP_COMPANY_ID/issues?q=search+term"

Present tasks as:

{PREFIX}-{number}: {title} [{status}] → @{assignee}
  Priority: {priority}
  Latest: "{last comment snippet...}"
  View: {baseUrl}/{prefix}/issues/{identifier}

Agent Monitoring

bash
# List all agents
curl -sS "$PAPERCLIP_API_URL/api/companies/$PAPERCLIP_COMPANY_ID/agents"

# Get agent detail
curl -sS "$PAPERCLIP_API_URL/api/agents/{id}"

# Get agent config revisions (change history)
curl -sS "$PAPERCLIP_API_URL/api/agents/{id}/config-revisions"

Present agents as:

Team Overview
─────────────
@ceo (Atlas) — active, last heartbeat 5m ago
  Budget: $45 / $100 (45%)
  Working on: PAP-12 Homepage redesign

@frontend-engineer — active, last heartbeat 2m ago
  Budget: $30 / $50 (60%)
  Working on: PAP-15 Blog template

Cost Monitoring

bash
# Overall summary
curl -sS "$PAPERCLIP_API_URL/api/companies/$PAPERCLIP_COMPANY_ID/costs/summary"

# Breakdown by agent
curl -sS "$PAPERCLIP_API_URL/api/companies/$PAPERCLIP_COMPANY_ID/costs/by-agent"

# Breakdown by project
curl -sS "$PAPERCLIP_API_URL/api/companies/$PAPERCLIP_COMPANY_ID/costs/by-project"

# Optional date range
curl -sS "$PAPERCLIP_API_URL/api/companies/$PAPERCLIP_COMPANY_ID/costs/summary?from=2026-03-01&to=2026-03-31"

Present costs as:

Costs This Month
────────────────
Total: $145.23 / $500.00 (29%)

By Agent:
  @ceo              $45.12 (31%)
  @frontend-eng     $62.30 (43%)
  @content-strat    $37.81 (26%)

Work Products

bash
# List work products for an issue
curl -sS "$PAPERCLIP_API_URL/api/issues/{issueId}/work-products"

# View a document
curl -sS "$PAPERCLIP_API_URL/api/issues/{issueId}/documents/{key}"

# View document revisions
curl -sS "$PAPERCLIP_API_URL/api/issues/{issueId}/documents/{key}/revisions"

Present work products with status and links:

Work Products — PAP-12
──────────────────────
1. Homepage mockup [ready_for_review] — artifact
   View: {baseUrl}/{prefix}/issues/PAP-12#document-mockup

2. Feature branch [active] — branch
   URL: https://github.com/...

Editing Agent System Prompts

Three ways the user can edit system prompts:

In chat: User describes changes, you update via API:

bash
# Always re-fetch before modifying
curl -sS "$PAPERCLIP_API_URL/api/agents/{id}"

# Then update
curl -sS -X PATCH "$PAPERCLIP_API_URL/api/agents/{id}" \
  -H "Content-Type: application/json" \
  -d '{"adapterConfig": { ... updated config ... }}'

Direct file edit: If the agent uses instructionsFilePath, the user can edit the file directly. When they tell you they're done, re-read the file and confirm changes.

Web UI edit: User edits at {baseUrl}/{prefix}/agents/{agentUrlKey}. When they say "sync up," re-fetch from the API.

Viewing change history:

bash
curl -sS "$PAPERCLIP_API_URL/api/agents/{id}/config-revisions"

Present as a changelog:

Config History — @designer
──────────────────────────
Rev 3 (2026-03-21 14:30) — changed: systemPrompt
  Added UX research to expertise section

Rev 2 (2026-03-21 10:15) — changed: budgetMonthlyCents
  Budget increased from $50 to $100

Rev 1 (2026-03-20 16:00) — initial configuration

Decision Log

Maintain a decision log for session continuity. Log major decisions — not every interaction.

What to log:

  • Company creation and configuration changes
  • Agents hired, modified, or removed
  • Budget changes
  • Strategic decisions (what was prioritized, what was cut and why)
  • Approvals granted or rejected with reasoning

When to log:

  • After completing a significant action (hiring, approving, budget change)
  • At the end of a session if notable decisions were made

How to log:

  1. Update the API document:
bash
# Fetch current log
curl -sS "$PAPERCLIP_API_URL/api/issues/{boardIssueId}/documents/decision-log"

# Update with new entries appended
curl -sS -X PUT "$PAPERCLIP_API_URL/api/issues/{boardIssueId}/documents/decision-log" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Decision Log",
    "format": "markdown",
    "body": "... existing content ... \n\n## {date}\n- New decision\n",
    "baseRevisionId": "{current revision id}"
  }'
  1. Also update the local file at ./artifacts/decision-log.md.

Presentation Rules

  • Use markdown tables for lists (agents, tasks, costs)
  • Use bold for status values: in_progress, blocked, completed
  • Always include web UI links: View: {PAPERCLIP_API_URL}/{prefix}/issues/{identifier}
  • For org charts: generate mermaid diagrams or ASCII art
  • Smart summaries: surface what needs attention first, then the rest
  • Task format: PAP-123: Build landing page [in_progress] → @engineer
  • Keep responses concise — the user can ask to drill deeper
  • When presenting multiple items for action (approvals, hires), number them for easy reference
  • Derive the company's URL prefix from any issue identifier (e.g., PAP-315 → prefix is PAP)

All web UI links must include the company prefix:

  • Issues: /{prefix}/issues/{identifier} (e.g., /PAP/issues/PAP-12)
  • Agents: /{prefix}/agents/{agent-url-key}
  • Approvals: /{prefix}/approvals/{approval-id}
  • Projects: /{prefix}/projects/{project-url-key}
  • Documents: /{prefix}/issues/{identifier}#document-{key}

Key Endpoints Reference

ActionMethodEndpoint
List companiesGET/api/companies
Create companyPOST/api/companies
Update companyPATCH/api/companies/:id
Get companyGET/api/companies/:id
DashboardGET/api/companies/:companyId/dashboard
List agentsGET/api/companies/:companyId/agents
Get agentGET/api/agents/:id
Update agentPATCH/api/agents/:id
Agent configsGET/api/companies/:companyId/agent-configurations
Config revisionsGET/api/agents/:id/config-revisions
Hire agentPOST/api/companies/:companyId/agent-hires
Invoke heartbeatPOST/api/agents/:id/heartbeat/invoke
List issuesGET/api/companies/:companyId/issues
Create issuePOST/api/companies/:companyId/issues
Get issueGET/api/issues/:id
Update issuePATCH/api/issues/:id
Issue commentsGET/api/issues/:id/comments
Add commentPOST/api/issues/:id/comments
Issue documentsGET/api/issues/:id/documents
Get documentGET/api/issues/:id/documents/:key
Create/update docPUT/api/issues/:id/documents/:key
Work productsGET/api/issues/:id/work-products
List approvalsGET/api/companies/:companyId/approvals
ApprovePOST/api/approvals/:id/approve
RejectPOST/api/approvals/:id/reject
Request revisionPOST/api/approvals/:id/request-revision
Cost summaryGET/api/companies/:companyId/costs/summary
Costs by agentGET/api/companies/:companyId/costs/by-agent
Costs by projectGET/api/companies/:companyId/costs/by-project
Adapter docsGET/llms/agent-configuration.txt
Adapter detailGET/llms/agent-configuration/:adapterType.txt
Agent iconsGET/llms/agent-icons.txt
Set instructionsPATCH/api/agents/:id/instructions-path
Search issuesGET/api/companies/:companyId/issues?q=term

© paperclipai, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/paperclip-board of paperclipai/paperclip.

Open the folder on GitHubat commit de9ab8e

Compare with similar skills

Paperclip Board next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Paperclip Board compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Paperclip Board this skillpaperclipai/paperclip100k—~5.3kAutomated safety check: PassMIT
PaperclipK-Dense-AI/scientific-agent-skills48k1 repos~3.2kAutomated safety check: NotesMIT
Company Brain Company QAtopoteretes/cognee32k—~750Automated safety check: NotesApache-2.0
Boardalirezarezvani/claude-skills28k—~610Automated safety check: PassMIT
Board Governancesickn33/agentic-awesome-skills47k1 repos~4.1kAutomated safety check: PassMIT
Announcement Boardsickn33/agentic-awesome-skills47k1 repos~3.4kAutomated safety check: PassMIT

Similar skills

  • Paperclip

    K-Dense-AI/scientific-agent-skills

    Searches and reads biomedical papers, FDA/PMDA/EMA documents, clinical trials, and protein records with the GXL Paperclip CLI and Python SDK.

    48k GitHub starsUsed in 1 repo~3.2k tokens
    Research & ScienceAuto-check: notes
  • Company Brain Company QA

    topoteretes/cognee

    Build one company memory from a SQL database, a support ticket export and a folder of documents, linked into one graph by cognee, then answer questions that need several of those sources together.

    32k GitHub stars~750 tokensUpdated yesterday
    Sales & SupportAuto-check: notes
  • Board

    alirezarezvani/claude-skills

    Read, write, and browse the AgentHub message board for agent coordination.

    28k GitHub stars~610 tokensUpdated 1 mo ago
    Agent WorkflowsAuto-check passed
  • Board Governance

    sickn33/agentic-awesome-skills

    Board and governance register: meeting date, agenda, decision, resolution number, vote result, action owner and due date.

    47k GitHub starsUsed in 1 repo~4.1k tokens
    Auto-check passed
  • Announcement Board

    sickn33/agentic-awesome-skills

    Announcement board: author, category, department, priority, audience, publish and expiry dates, status and acknowledgements, as CSV, SQL, JSON Schema or Notion on request.

    47k GitHub starsUsed in 1 repo~3.4k tokens
    Documents & OfficeAuto-check passed
  • Pre Boarding

    sickn33/agentic-awesome-skills

    Pre-boarding checklist: task, employee and department, owner, category, joining and due dates, documents received, laptop, email and account-record readiness, status.

    47k GitHub starsUsed in 1 repo~3.5k tokens
    Auto-check passed

More from paperclipai/paperclip

All 60 skills in this repo
  • Garden Inbox

    paperclipai/paperclip

    Scan a Paperclip user's Mine inbox, classify reversible archive candidates, request checkbox confirmation, and archive only accepted selections.

    100k GitHub stars~1.1k tokensUpdated today
    Auto-check passed
  • Paperclip

    paperclipai/paperclip

    Interact with the Paperclip control plane API for task coordination and governance.

    100k GitHub stars~9.6k tokensUpdated today
    Auto-check passed
  • Paperclip

    paperclipai/paperclip

    A skill your agent uses for Paperclip-managed tasks and heartbeats: reading task context, delivering task documents or files, updating completion or blockers, coordinating or delegating work, and…

    100k GitHub stars~18k tokensUpdated today
    Auto-check passed
  • Design Guide

    paperclipai/paperclip

    Paperclip UI design system guide for building consistent, reusable frontend components.

    100k GitHub starsUsed in 1 repo~3.1k tokens
    Auto-check passed
  • Paperclip Page

    paperclipai/paperclip

    Publish static HTML pages and asset folders to the Paperclip S3/CloudFront page host.

    100k GitHub stars~1k tokensUpdated today
    Auto-check passed
  • Paperclip Create Agent

    paperclipai/paperclip

    Create new agents in Paperclip with governance-aware hiring.

    100k GitHub starsUsed in 1 repo~2.1k tokens
    Auto-check passed

Questions about Paperclip Board

What does Paperclip Board do?

Manage a Paperclip company as a board member via chat. An agent skill from paperclipai/paperclip. Paperclip Board is an agent skill from paperclipai/paperclip. Manage a Paperclip company as a board member via chat.

When should I use Paperclip Board?

Paperclip Board fits situations like: the user wants onboarding; agent management; task monitoring; work product review in the Paperclip control plane.

How do I install Paperclip Board in Claude Code?

Run `npx skills add paperclipai/paperclip --skill paperclip-board -a claude-code`. Or copy the skill folder (skills/paperclip-board in paperclipai/paperclip) into .claude/skills/paperclip-board in your project. Claude Code loads it when a task matches its description.

How do I install Paperclip Board in Codex?

Run `npx skills add paperclipai/paperclip --skill paperclip-board -a codex`. Or copy the skill folder (skills/paperclip-board in paperclipai/paperclip) into .agents/skills/paperclip-board in your project. Codex loads it when a task matches its description.

Can I use Paperclip Board in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add paperclipai/paperclip --skill paperclip-board -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/paperclip-board, .gemini/skills/paperclip-board, .github/skills/paperclip-board and .opencode/skills/paperclip-board in your project.

What does Paperclip Board need to run?

Going by SKILL.md and its folder, Paperclip Board needs the command-line tools its instructions call (curl and npx) and credentials named PAPERCLIP_API_KEY. Our summary lists: Node.js; A credential in PAPERCLIP_API_KEY.

Does Paperclip Board access the network?

SKILL.md names 1 domain. In commands or code: github.com; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.

Is Paperclip Board safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Paperclip Board use?

Paperclip Board is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Paperclip Board use?

About 5.3k tokens (SKILL.md is roughly 21k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Paperclip Board?

Skills that share tags, products or a category with Paperclip Board: Paperclip (K-Dense-AI/scientific-agent-skills, 48k stars), Company Brain Company QA (topoteretes/cognee, 32k stars), Board (alirezarezvani/claude-skills, 28k stars) and Board Governance (sickn33/agentic-awesome-skills, 47k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Paperclip Board?

paperclipai (a GitHub organization) maintains it in paperclipai/paperclip, which has 99,905 GitHub stars. The repository holds 60 skills in this directory. The repository was last updated on October 11, 2026.

Source: paperclipai/paperclip on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.