ClipHub and the Paperclip Ecosystem: Templates, Plugins, and Community

Designing an AI agent from scratch is deceptively time-consuming. Before a single productive task runs, you have already spent hours tuning the system prompt, calibrating the heartbeat interval, setting a sensible budget envelope, and deciding which tools the agent should have access to. Multiply that by a team of six or eight agents and you have invested days before your Paperclip company does anything useful.

ClipHub is the answer to that problem. It is Paperclip’s built-in marketplace for production-ready agent templates — pre-configured role definitions that you install in seconds and customize from a known-good baseline. But ClipHub is not the full story. The Paperclip ecosystem extends outward to external AI agents like Claude, Codex, and Cursor; to a growing community of open-source contributors building and publishing their own templates; and to a React-based dashboard that ties it all together.

This guide covers every layer of that ecosystem: how to browse and install ClipHub templates, which external agents plug into Paperclip natively, how to build and publish your own templates, and where to find the community resources that will help you grow your Paperclip operation over time. Before diving in, make sure you have a running Paperclip installation — the installation guide covers everything you need to get there.

The Paperclip Ecosystem

When Paperclip launched as an open-source project, it shipped with a control plane, a governance model, and a REST API. What it did not ship with was an answer to the question every new user asks immediately: “What do I put inside this thing?” Defining effective agents is hard. Designing a coherent org chart for a set of AI agents that actually work together is harder. The ecosystem is Paperclip’s evolving solution to that problem.

The ecosystem has three concentric layers.

The Paperclip core handles orchestration, governance, budget enforcement, heartbeat scheduling, multi-company isolation, and the REST API. This is the infrastructure layer — it runs the company but does not tell you what the company should do or who should work there.

ClipHub sits on top of the core as a content and distribution layer. It is a marketplace of agent templates, where each template defines a complete agent configuration — role, responsibilities, system prompt, heartbeat interval, default budget, and tool access. Templates are authored by the Paperclip team, by partner organizations, and by the open-source community. ClipHub turns the question “how do I define a good senior Python engineer agent?” into a one-line install command.

External agent integrations extend the ecosystem outward, connecting Paperclip’s governance and orchestration layer to AI systems it did not build internally. When Paperclip coordinates a Claude agent for writing tasks, a Codex agent for code generation, or a Cursor agent for IDE-level code navigation, it acts as a meta-orchestration layer — applying budget controls, audit logging, and org-chart accountability to work that is ultimately performed by external AI systems.

Together, these three layers give Paperclip an unusually complete answer to the “now what?” question that follows a fresh install. You have the infrastructure, you have a library of proven agent configurations, and you have connectors to the best external AI tools available today.

ClipHub Marketplace

ClipHub is accessible through the Paperclip React dashboard and through the paperclipai CLI. The dashboard view lets you browse templates by category, read documentation, see version history, and preview the default configuration before installing. The CLI gives you the same access from the terminal, which is preferable for scripted provisioning and CI/CD pipelines.

Browsing and Searching

From the dashboard, navigate to the ClipHub tab. Templates are organized by role category: Engineering, Research, Marketing, Operations, Executive, and Community. Each template card shows the publisher name (namespaced as publisher/template-name), a short description, the default model configuration, the heartbeat interval, and the default monthly budget estimate.

From the CLI, you can search templates without opening the dashboard:

# List all templates in the engineering category
paperclipai cliphub list --category engineering

# Search templates matching a keyword
paperclipai cliphub search "python"

# View detailed information about a specific template
paperclipai cliphub info acme/senior-python-eng

The cliphub info command returns the full template manifest — every configuration field that will be applied when you install the template — so you can review it before committing.

Installing Agent Templates

Installing a single agent template into the current company context requires one command:

# Install a single agent template
paperclipai install cliphub:acme/senior-python-eng --agent

# Install with a custom agent name to distinguish multiple instances
paperclipai install cliphub:acme/senior-python-eng --agent --name "backend-python-lead"

# Install targeting a specific company (useful in multi-company deployments)
paperclipai install cliphub:acme/research-analyst --agent --company acme-internal

The --agent flag signals that you are installing an agent template (as opposed to a plugin or workflow template). After installation, the agent appears in your company’s roster in the dashboard with status inactive. It will not start consuming heartbeats or budget until you explicitly activate it.

Installing Company Templates

For larger provisioning scenarios, ClipHub offers company-level templates that install an entire org chart in a single command:

# Install a full development team configuration for a company
paperclipai install cliphub:acme/devteam

# Install with interactive confirmation for each agent
paperclipai install cliphub:acme/devteam --confirm-each

# Dry run — preview what would be installed without making changes
paperclipai install cliphub:acme/devteam --dry-run

A company template bundles multiple agent definitions along with a pre-configured reporting hierarchy, shared goal templates, and recommended budget allocations per role. The acme/devteam template, for example, provisions a CTO agent, two senior engineer agents, a QA engineer agent, and a technical writer agent — all wired into an org chart where the engineers report to the CTO. Running a single install command can save several hours of manual configuration.

Versioning and Pinning

Templates follow semantic versioning. By default, paperclipai install fetches the latest stable version. For production deployments, pin to a specific version to prevent unexpected behavior changes when templates update:

# Install a specific version
paperclipai install cliphub:acme/[email protected] --agent

# Check available versions for a template
paperclipai cliphub versions acme/senior-python-eng

# Update an installed template to the latest version
paperclipai cliphub update acme/senior-python-eng

After updating a template, the agent remains on its old configuration until you restart it. This gives you a maintenance window to review what changed before the new configuration takes effect.

Pre-Built Agent Templates

ClipHub’s template library covers the most common roles across engineering, research, marketing, and operations. The table below shows a representative selection of popular templates across categories, along with the roles each template includes and the primary use cases they serve.

Templates in the community/ namespace are contributed by Paperclip users rather than the core team. They go through a review process before appearing in the marketplace — described in the Building and Publishing section below — but community templates may have less polish than first-party templates. Always review the manifest with paperclipai cliphub info before installing a community template in a production company.

Customizing After Installation

Every template is a starting point, not a final configuration. After installing, you can override any field through the dashboard or the REST API. Common customizations include adjusting the system prompt to reflect your company’s specific context, tightening the budget to match your actual cost targets, and modifying the heartbeat interval based on how time-sensitive the agent’s work needs to be:

# Update an installed agent's configuration via the CLI
paperclipai agent update backend-python-lead \
  --heartbeat-interval 1800 \
  --budget-hard-limit 25.00 \
  --system-prompt-append "Our codebase uses Python 3.11, FastAPI, and SQLAlchemy 2.0. Always use async/await for database operations."

The --system-prompt-append flag adds your text to the end of the template’s default system prompt without overwriting it, which is usually safer than replacing the entire prompt when you are not sure what the template baseline contains.

External Agent Integration

One of Paperclip’s most distinctive capabilities is that it functions as a meta-orchestration layer over external AI agents that it did not build. Rather than replacing Claude, Codex, or Cursor, Paperclip wraps them in its governance model — applying budget tracking, audit logging, heartbeat scheduling, and org-chart accountability to work performed by external systems. The result is that you get the specialized capabilities of each external agent combined with the operational discipline of Paperclip’s control plane.

Paperclip currently ships with built-in adapters for four external agents: OpenClaw, Claude, Codex, and Cursor.

Connecting Claude

Claude (Anthropic) is the external agent most commonly used in Paperclip deployments for writing-heavy tasks: long-form research, technical documentation, code explanation, and nuanced analysis. The Claude adapter connects via Anthropic’s API:

# Set the Anthropic API key in Paperclip's secret vault
paperclipai secrets set ANTHROPIC_API_KEY "sk-ant-..."

# Create a new agent that uses the Claude backend
paperclipai agent hire \
  --name "documentation-writer" \
  --role "Technical Writer" \
  --backend claude \
  --model "claude-3-5-sonnet-20241022" \
  --budget-hard-limit 30.00 \
  --heartbeat-interval 3600

Once created, the agent appears in your dashboard like any Paperclip-native agent. The adapter translates Paperclip task assignments into Anthropic API calls, captures token usage for budget accounting, streams results back to the Paperclip server, and emits heartbeats on the agent’s behalf so the control plane always knows the task is progressing.

You can also configure Claude-specific options through the adapter configuration:

# Advanced Claude adapter configuration
paperclipai agent update documentation-writer \
  --adapter-config '{
    "temperature": 0.7,
    "max_tokens": 8192,
    "system_prompt_prefix": "You are a technical writer at Acme Corp...",
    "tools": ["web_search", "file_read"]
  }'

Connecting Codex

The Codex adapter (GitHub Copilot API or OpenAI Codex endpoint) is optimized for code generation, code completion, and code transformation tasks. It handles structured programming tasks more efficiently than general-purpose models and is well-suited for engineering agents that need to produce functional code rather than explanatory prose:

# Set the OpenAI API key
paperclipai secrets set OPENAI_API_KEY "sk-..."

# Hire a code generation agent using Codex
paperclipai agent hire \
  --name "code-generator" \
  --role "Senior Engineer" \
  --backend codex \
  --model "code-davinci-002" \
  --budget-hard-limit 20.00 \
  --heartbeat-interval 900

Connecting Cursor

The Cursor adapter is unique because Cursor is an IDE agent rather than a pure API service. The adapter connects to a locally running Cursor instance and allows Paperclip to dispatch tasks that involve navigating a codebase, making edits across multiple files, running tests, and interpreting compiler output — capabilities that require IDE-level context that API-only models lack:

# Install and configure the Cursor adapter plugin
paperclipai plugin install paperclip-cursor-adapter

# Register a local Cursor instance
paperclipai agent hire \
  --name "ide-refactor-agent" \
  --role "Senior Engineer" \
  --backend cursor \
  --cursor-workspace "/home/dev/projects/acme-backend" \
  --budget-hard-limit 15.00 \
  --heartbeat-interval 1800

The Cursor adapter requires the paperclip-cursor-adapter plugin to be installed and a running Cursor instance with the Paperclip extension enabled. This is a more involved setup than the API-based adapters, but it unlocks refactoring and codebase navigation tasks that no API-only agent can perform as reliably.

Connecting OpenClaw

OpenClaw is a purpose-built open-source orchestration and skills agent — see our guide on OpenClaw integrations and community for details on what it offers. The Paperclip-to-OpenClaw integration connects the two orchestration layers, allowing Paperclip to delegate subtasks to OpenClaw’s skills runtime while retaining governance over the overall workflow:

# Set OpenClaw connection details
paperclipai secrets set OPENCLAW_API_URL "http://localhost:8080"
paperclipai secrets set OPENCLAW_API_KEY "oclaw-..."

# Register an OpenClaw-backed agent in Paperclip
paperclipai agent hire \
  --name "skills-executor" \
  --role "Specialist" \
  --backend openclaw \
  --budget-hard-limit 25.00 \
  --heartbeat-interval 600

When Paperclip dispatches a task to the OpenClaw-backed agent, the OpenClaw adapter translates the task into an OpenClaw skill invocation, streams results back to Paperclip’s server, and handles heartbeat emissions so the Paperclip control plane maintains accurate task state throughout execution.

Building and Publishing Templates

Publishing a ClipHub template is how you contribute back to the Paperclip community — and how you distribute your own polished agent configurations to other operators. The process involves three steps: authoring a template manifest, testing the template in a local Paperclip installation, and submitting it through the ClipHub pull request process.

Template Manifest Format

Every ClipHub template is a YAML manifest file that fully describes an agent configuration:

# cliphub-template.yaml
name: "senior-python-eng"
publisher: "acme"
version: "1.0.0"
category: "engineering"
description: "A senior Python engineer agent for code review, implementation, and refactoring tasks."
license: "MIT"

agent:
  role: "Senior Engineer"
  default_name: "senior-python-eng"
  backend: "claude"
  model: "claude-3-5-sonnet-20241022"
  heartbeat_interval_seconds: 1800
  budget:
    soft_limit_usd: 15.00
    hard_limit_usd: 25.00
    period: "monthly"
  system_prompt: |
    You are a senior Python software engineer. Your responsibilities include:
    - Reviewing pull requests for correctness, style, and performance
    - Implementing features from specifications with full test coverage
    - Refactoring legacy code to improve readability and maintainability
    - Diagnosing and fixing bugs with clear explanations

    Always write production-quality code. Include type annotations, docstrings,
    and unit tests in your implementations. When reviewing code, provide specific,
    actionable feedback rather than general observations.
  tools:
    - file_read
    - file_write
    - bash_exec
    - web_search
  metadata:
    language: "Python"
    frameworks: [FastAPI, SQLAlchemy, pytest, pydantic]
    difficulty: intermediate
    estimated_monthly_cost_usd: 12.00

For company templates that provision multiple agents, the manifest includes an org_chart section defining the reporting relationships:

# company-template.yaml
name: "devteam"
publisher: "acme"
version: "2.0.0"
category: "engineering"
description: "A complete development team with CTO, engineers, QA, and a technical writer."

agents:
  - id: cto
    template: "acme/cto"
    version: "1.2.0"
  - id: backend-eng-1
    template: "acme/senior-python-eng"
    version: "2.1.0"
  - id: backend-eng-2
    template: "acme/senior-python-eng"
    version: "2.1.0"
    name_suffix: "-2"
  - id: qa-engineer
    template: "acme/qa-engineer"
    version: "1.0.0"
  - id: tech-writer
    template: "acme/technical-writer"
    version: "1.1.0"

org_chart:
  - manager: cto
    reports: [backend-eng-1, backend-eng-2, qa-engineer, tech-writer]

Testing Before Publishing

Before submitting a template to ClipHub, validate it in your local Paperclip installation using the --dry-run flag and the built-in template linter:

# Validate template manifest syntax and required fields
paperclipai cliphub lint cliphub-template.yaml

# Dry-run install to preview what would be created
paperclipai install ./cliphub-template.yaml --dry-run

# Run the template test suite (requires a local Paperclip server)
paperclipai cliphub test ./cliphub-template.yaml --run-heartbeat

The --run-heartbeat flag activates the installed agent for a single heartbeat cycle so you can verify it connects to its backend, completes a test task, and reports results correctly before submitting.

Submission Process

ClipHub templates are hosted in the paperclipai/cliphub GitHub repository. The submission workflow follows standard open-source conventions:

# Fork and clone the ClipHub repository
git clone https://github.com/paperclipai/cliphub.git
cd cliphub

# Create a branch for your template
git checkout -b add-template/acme/senior-python-eng

# Add your template manifest to the appropriate category directory
cp /path/to/cliphub-template.yaml templates/engineering/acme/senior-python-eng.yaml

# Run the automated test suite
npm test

# Commit and push
git add templates/engineering/acme/senior-python-eng.yaml
git commit -m "Add acme/senior-python-eng template v1.0.0"
git push origin add-template/acme/senior-python-eng

After opening a pull request, the ClipHub review bot runs automated checks: manifest schema validation, system prompt safety scanning, and a sandboxed heartbeat test against a real Paperclip instance. Human reviewers from the core team then do a final review focusing on the quality of the system prompt, the reasonableness of the default budget, and whether the template fills a genuine gap in the existing library. Review typically completes within three to five business days for well-prepared submissions.

Community and Resources

The Paperclip community is built primarily around GitHub and async communication channels. It skews technical — most participants are developers integrating Paperclip into real production workflows rather than evaluators or students — so the quality of discussion in community channels tends to be high and the feedback on pull requests substantive.

GitHub Repository

The primary resource for everything Paperclip is the GitHub organization at github.com/paperclipai. The main repositories are:

• paperclipai/paperclip — the core server, REST API, and React dashboard
• paperclipai/cliphub — the marketplace template library
• paperclipai/paperclipai-cli — the paperclipai command-line tool
• paperclipai/adapters — external agent adapter plugins (Claude, Codex, Cursor, OpenClaw)

The issue tracker on paperclipai/paperclip is the right place to report bugs, request features, and track the project roadmap. The repository uses a public project board that shows what the core team is actively working on, what is backlogged, and what community contributions are most wanted.

Community Channels

Beyond GitHub, the Paperclip community maintains the following channels:

• Discord — The most active real-time channel for questions, showcase posts, and general discussion. The #cliphub channel is specifically for template authors to get feedback before submitting to the marketplace.
• GitHub Discussions — For longer-form technical questions and design proposals that would be lost in Discord’s scroll. Use this for questions like “how should I design my org chart for a content production workflow?”
• Weekly Office Hours — The core team hosts a weekly video call open to all community members. Timestamps and recordings are posted to GitHub Discussions.

Contributing to Core

Contributing to paperclipai/paperclip core follows a standard fork-and-PR workflow. The project uses TypeScript strict mode throughout and enforces formatting with ESLint and Prettier. All pull requests require at minimum one automated CI pass and one human review before merging.

For first-time contributors, the issue tracker’s good first issue label lists tasks that are scoped to be approachable without deep familiarity with the codebase. The help wanted label identifies issues where the core team has defined the expected approach but does not have bandwidth to implement it.

For adapter development (adding support for a new external AI agent), the paperclipai/adapters repository maintains a contribution guide that walks through the adapter interface contract, the heartbeat emission requirements, and the test harness you need to satisfy before your adapter will be reviewed. If you are familiar with the AutoGPT plugin development model, the Paperclip adapter interface follows similar conventions — the AutoGPT plugins and community guide is useful background reading for understanding how community-driven plugin ecosystems evolve in open-source agent projects.

Frequently Asked Questions

How does ClipHub handle template versioning?

Each ClipHub template uses semantic versioning (MAJOR.MINOR.PATCH). Patch releases fix bugs without changing behavior. Minor releases add optional fields or expand capabilities in a backward-compatible way. Major releases indicate breaking changes — usually a significant restructuring of the system prompt, a change in required tools, or a shift in the assumed backend model. When you install a template, Paperclip records the exact version in your company’s configuration so you can always roll back to a previous version if an update causes problems. The paperclipai cliphub versions command shows the full version history for any template, and paperclipai cliphub changelog acme/senior-python-eng displays the diff between any two versions before you decide to upgrade.

Can I publish private templates for my team only?

Yes. ClipHub supports private template registries that function identically to the public marketplace but are only accessible to members of your Paperclip organization. To set up a private registry, add a registry configuration to your paperclipai.config.json:

{
  "registries": [
    {
      "name": "public",
      "url": "https://cliphub.paperclipai.com",
      "public": true
    },
    {
      "name": "private",
      "url": "https://cliphub.your-org.internal",
      "public": false,
      "auth": {
        "type": "bearer",
        "token_env": "PRIVATE_CLIPHUB_TOKEN"
      }
    }
  ]
}

Private registries can be self-hosted using the open-source paperclipai/cliphub-server package, which implements the full ClipHub API surface. For teams that want private templates without the operational overhead of self-hosting, the Paperclip cloud offering includes a managed private registry as part of its team plan.

Can I use ClipHub templates commercially?

The licensing terms for each template are set by the template author and displayed in the cliphub info output and on the template’s marketplace page. Templates published by the Paperclip core team (acme/ namespace) are released under the MIT license, which permits unrestricted commercial use, modification, and redistribution. Community templates (community/ namespace) may carry different licenses — Apache 2.0 and MIT are common, but always check before using a community template in a commercial product. Template licenses cover the template manifest itself (the YAML configuration and system prompt text). Your company’s data, task results, and agent outputs are always your own and are not subject to the template license.

Next Steps

You now have a complete picture of the Paperclip ecosystem: ClipHub’s template marketplace, external agent integrations, and the community processes that sustain the project’s growth. Here is where to take this knowledge next.

Start with ClipHub. If you have a running Paperclip installation, the fastest way to see ecosystem value is to install one of the popular engineering templates and run it through a real heartbeat cycle. The acme/senior-python-eng template is a good starting point because code review tasks are easy to evaluate — you know immediately whether the output is useful. Run paperclipai install cliphub:acme/senior-python-eng --agent and assign it a task within ten minutes.

Connect an external agent. If your workflow involves writing-heavy tasks, wire up the Claude adapter and experiment with routing documentation or research tasks to a Claude-backed agent. Seeing Paperclip’s governance layer apply to an externally executed Claude task is one of the clearest demonstrations of the platform’s value — you get a budget-controlled, audit-logged Claude agent operating within your org chart without writing any adapter code yourself.

Browse the community templates. The community/ namespace grows with each quarter of active contribution. Spend fifteen minutes browsing current community templates with paperclipai cliphub list --category community — there is often a template that is surprisingly close to what your next agent needs, which means a much shorter path from idea to running agent than building from scratch.

Contribute a template. If you have been running a Paperclip company for a few weeks and have refined an agent configuration that works well for your use case, consider publishing it to ClipHub. Well-authored community templates benefit the whole ecosystem, and the review process provides useful external feedback on your agent design decisions.

For deeper context on how community ecosystems evolve in open-source agent platforms, the AutoGPT plugins and community guide and the OpenClaw integrations and community guide both offer useful perspectives from adjacent projects navigating similar challenges.