Paperclip: Open Source Human Control Plane for AI Labor — Dotta

How do you give an organization of AI agents real work while retaining control over what they produce? Paperclip starts with an org chart: hire agents, set goals, and automate jobs. Its creator, Dotta, introduces the product through the ambition of a zero-human company, then gives it a more practical definition: a human control plane for AI labor. The human supplies the taste and direction that turn agent activity into useful work.

The walkthrough begins with local onboarding:

npx paperclipai onboard

To accept the default options:

npx paperclipai onboard --yes

These are the commands demonstrated in the recording; the current repository setup guide includes updated prerequisites, installation options, and registry guidance.

The operating premise is that you remain accountable for the work. Your preferences belong in the process from high-level design through execution, rather than appearing only after an agent has produced a finished result. Dotta first tours the instance he uses to manage Paperclip itself, then creates a new company to show how that structure begins.

In the existing company, a CEO sits above a CTO and a collection of coders. Dotta most often uses a Codex coder and a Claude coder, but Paperclip follows a bring-your-own-agent approach: Gemini, Pi, Hermes, and OpenClaw are other examples he names. The orchestrator gives these agents a shared organizational setting in which they can communicate, negotiate, and store memory.

The same structure extends beyond engineering. A CMO oversees marketing specialists, including a content strategist and a video writer. The org chart makes those responsibilities visible instead of leaving them implicit in separate chat sessions.

Dotta reports that Paperclip had crossed 40,000 GitHub stars that week. He expects it to pass 50,000 by the time people watch the recording. Normally, he would celebrate with a tweet or a screenshot; this time, he creates an issue and assigns it to the CEO agent. The human directs the CEO, which breaks the request down through executives to individual contributors. That hierarchy provides a route from a business objective to the agents that can carry it out.

The request is to hire a video writer and make a Remotion video celebrating the milestone. Hiring does not require the human to configure every step manually: Paperclip exposes its application operations to agents, so the CEO can hire another agent and install skills through the built-in skills manager. Here it uses the Remotion best-practices skill from skills.sh. Remotion creates videos in React; Dotta presents this workflow as requiring no additional signup.

Once the writer is hired and equipped, the task proceeds through a short planning loop:

1. Reference existing work. Dotta asks the writer to inspect the stats dashboard, using an @ mention to refer to an existing project.
2. Request a plan. The writer proposes a video celebrating 40,000 stars. Paperclip treats the plan as a first-class work product that the human can read and discuss.
3. Correct the creative choices. Dotta asks for cuts of about two seconds rather than six, and for the star count itself to animate.

The human's contribution is specific editorial direction: what should move, how quickly the video should progress, and what deserves emphasis.

Dotta reports an on-brand animation with real statistics and charts in about five minutes after feedback. That result depended on an existing dashboard, brand guidance, an installed skill, and human revisions. A standalone Claude Code session could do similar work, but the operator would first need to collect the statistics, locate the brand guide, supply the Remotion skill, and provide dashboard access. Paperclip already held those pieces of context. Dotta contrasts the result with something that might previously have taken him a week; the useful mechanism is reusing organizational context across tasks, rather than rebuilding it for each prompt.

After several videos, the conversation history becomes material for improving the writer's instructions. A generic Remotion skill explains the tool; a Paperclip-specific skill can add brand identity, style, and pacing preferences. If the human repeatedly changes six-second cuts to two-second cuts, that preference should become part of how the agent starts its next assignment. In the demonstrated version, Dotta creates an agent to learn from those conversations; deeper integration of that learning is planned.

Dotta dates the release to March 4 and the recording to April 8, describing a product only about a month into open-source development and changing rapidly through community contributions. The basic interface is familiar task management: configure agents in an org chart, organize projects, and assign tasks. But an assignment alone does not ensure that an agent stays on task or satisfies the expected checks.

QA is one way to make the expectation operational. A QA agent can use agent-browser to open a website, fill a form, and click buttons. Dotta describes the familiar failure of juggling dozens of Claude Code tabs, asking a coder to test in the browser, and receiving work without that test. Tool-specific hooks can help, but Claude and Codex hooks differ. Paperclip places the workflow above those individual agent harnesses, allowing agents from different labs to participate in the same process.

The essential distinction is between completion, review, and approval:

In the workflow Dotta describes, finishing the assigned task must start the QA agent. The reviewer and coder can iterate before a manager decides whether their result is sufficient. Requiring that handoff is stronger than relying on a coder to remember a request buried in its prompt. Dotta attributes greater reliability to this arrangement, without presenting a measured reliability comparison.

Not all work begins with a new issue. Dotta saves Twitter bookmarks containing ideas for improving Paperclip and uses routines for recurring tasks. Other examples include handling pull requests, posting a Discord summary of everything merged into master that day, and writing release changelogs. Routines can be grouped by project or agent and run on a schedule or manually.

A routine can also accept an input when it runs. The demonstrated pull-request routine uses a branch placeholder, {{branch}}, so the operator can supply the relevant branch without copying and editing a prompt from a folder. The reusable part is the procedure; the branch changes from one invocation to the next.

Routines and skills overlap, but they can work together. An organization that already has a skill for handling pull requests can invoke it inside a routine. Paperclip uses Greptile for first-pass reviews of community contributions; the demonstrated routine asks the agent to use the Greploop skill after submitting a PR, connecting that submission to the GitHub review process.

The coding examples are one application of the organization, not the boundary of the product. Paperclip is intended to coordinate business work while people continue using tools such as Cursor and GitHub where appropriate. Dotta names marketing, sales leads, and finance operations as other areas in which agents can take assignments.

The bookmark workflow illustrates this broader scope. Its strategy report collects ideas about execution adapters, memory adapters, and CLI-versus-chat interaction. At the time of the demonstration, the output is a report. Dotta describes a future interface with actions to create an issue, request a plan, or begin integrating an idea as a feature. Those buttons are proposed follow-up mechanisms, not actions shown executing in the walkthrough.

The instance can hold multiple companies. For the live setup, Dotta starts with the idea of an MCP directory and develops it into an agent-tools directory that charges for hosted tools. The proposed business would proxy third-party tools so an agent authenticates once and its access can be controlled centrally. This business description gives the first agent something more concrete than an instruction to start a company.

The initial setup has three decisions:

1. Choose the CEO agent. The interface offers Gemini, OpenCode, Hermes, Pi, and Cursor, among other agent types. Dotta recommends Claude Code or Codex for this role.
2. Set the first assignment. The default task is to hire the first engineer and create a hiring plan. It can be rewritten for a marketing or sales organization.
3. Add business constraints. Dotta adds that the product will need partnerships with large SaaS companies.

Those requirements matter because the agents cannot infer what the human values. After setup, the new org contains one CEO agent, which begins working on the hiring plan.

Importable templates can supply a much larger organization, but Dotta advises against starting with a 130-agent template before establishing how the agents should behave. In the live company, the CEO requests permission to hire a CTO, and Dotta explicitly approves that hire. The organization grows through a concrete need and an approval, rather than through a speculative org chart. Add agents individually, establish their quality, and fan out when the work warrants it.

Different roles need different levels of model capability. Dotta suggests reserving frontier-model spending for the agents that need it, while using cheaper models where they are sufficient. Paperclip supports OpenRouter through the OpenCode agent. As a recording-time example, he points to Qwen 3.6 Plus being free up to usage limits. He also cautions that cheaper models may not handle the most demanding work well. The choice is about the requirements of the role, not simply minimizing the price of every run.

Meanwhile, the CEO has produced a phased hiring plan: CTO first, then core engineering, then go-to-market. Dotta approves the plan and tells the CEO to continue, allowing it to hire the remaining team. Paperclip tracks monthly spending and offers budgets per agent and per project. The displayed zero monthly spend reflects Dotta's use of Claude and Codex subscriptions, not zero operating cost. He notes that subscriptions may not be sufficient as the team scales.

The company now has work underway on a prototype SaaS partner integration, development infrastructure, and product infrastructure. Dotta describes the default agent concurrency setting as one parallel run, with an option to increase it; he leaves the defaults unchanged. More agents and more concurrent runs are separate decisions, and the walkthrough does not require turning either setting up immediately.

Agent configuration is ongoing work. Dotta continually revises the Codex coder's instructions in response to behavior he wants to change:

• Blockers: Give a best-guess fix and explain how to carry it out, rather than only reporting that the task is blocked.
• Testing scope: Avoid turning a task that needs tests into writing an entire test suite.
• Corrections: Stop when an agent behaves poorly and take the time to improve its instructions.

These are concrete operating preferences. They tell an agent what a useful response looks like when the task becomes difficult or its scope starts expanding.

The established organization also has a Skill Consultant. This agent works with other agents to improve their use of skills; when an agent fails to use an expected skill, Dotta asks the consultant to diagnose the problem and iterate. Much of that organizational learning is still manual in the demonstrated version, with automation under development. The consultant makes improvement itself an assigned responsibility rather than an incidental conversation.

The version on screen has experimental isolated workspaces for coding workflows involving pull requests and worktrees. Dotta then opens the repository roadmap to discuss missing capabilities. During that visit, he notices and reports that Paperclip has crossed 50,000 GitHub stars. Artifacts, deployments, and CEO chat are among the features he describes as upcoming.

The roadmap extends several parts of the operating model:

• Sustained execution: A proposed maximizer mode would keep agents working toward a business goal when the user has tokens to spend and wants them to continue without stopping.
• Human collaboration: Multiple human users are missing in the demonstrated version. Dotta says work is underway so an entire team can use a cloud deployment.
• Remote execution: Planned cloud and sandbox options include E2B, exe.dev, and Claude agent deployments.
• Distribution and shared context: Plans include a free open-source desktop app, cloud deployments, hosted Paperclip cloud, and improvements to stability, memory, and the knowledge base.

Dotta presents these as work for roughly the next month and asks viewers to check the latest version. That is the recording's roadmap, not a delivery record: the current repository marks multiple human users, sandbox agents, and artifacts complete, while organizational learning, maximizer mode, CEO chat, and the desktop app remain unchecked.

Returning to the new company, the agents are working on deployment infrastructure, a CI pipeline, and initial partner integrations. The walkthrough ends with those tasks underway, not with a completed deployment. Dotta identifies marketing as a likely next assignment: the organization has begun executing, and the human is already deciding where its attention should go next.

Dotta's ambition is for a free product that lets people direct AI labor at a much larger scale—even thousands of agents—rather than treating automation only as a threat to their own work. The practical responsibilities he ends on are more immediate: debug what is happening, guide individual agents, and provide the context they need to meet the quality of the brand. His invitation to launch Paperclip includes nontechnical users. The continuing human job is to make the work worth doing and make its results good enough to use.