75 Tasks, One Window: Paperclip as a Team OS for Scattered Operators

I’ll skip the framing and start with the number. Yesterday I dumped seventy-plus open tasks into one local web UI, and for the first time in a year I could see all of them. Not in my head. Not in a Notion I never open. Not in a tasks.md I forgot existed. In one searchable, filterable, queryable place — with an AI team underneath ready to actually execute most of them.

That tool is Paperclip. I’ve been using it for two days. This post is an honest review.

The Problem It Solves (and Why It Matters Especially for Scattered Brains)

The honest version of my workflow last month: many Claude Code windows. One per active line of work. Each had its own context, its own memory, its own running tasks.

When I switched between them I was switching between operating systems. The cognitive tax was enormous. And like a lot of operators I know, I have whatever you want to call the brain that doesn’t enjoy that — call it ADHD, scattered attention, a too-many-projects life, doesn’t matter. The shape of the pain is the same: task list lives in my head; head leaks; tasks die.

Paper doesn’t work because most of these tasks are not for me to do. They’re for agents to do. Notion doesn’t work because Notion is a database, not a system that runs the work. Linear doesn’t work because Linear assumes a human team you talk to in Slack. None of these are designed for the actual situation, which is: one person and a fleet of AI agents working in parallel across many lives.

That is exactly what Paperclip is for.

What Paperclip Actually Is

Paperclip is an open-source control plane for AI agents. It is not an agent runtime. It runs on top of agent runtimes — Claude Code, OpenClaw, Codex, Cursor — and gives you the layer that all of them are missing: a place to define your team, assign tasks, watch heartbeats, and see what each agent is doing without opening a separate window.

The metaphor that works for me: if Claude Code is an employee, Paperclip is the company. It is the org chart, the kanban board, the budget tracker, and the audit log all in one place.

It runs locally on localhost:3100 via npx paperclipai run. Postgres is auto-embedded. The web UI is served from the same port. Setup took five minutes.

The crucial thing to understand: it’s not really a task tracker. It’s a team management system. The tasks are how the team coordinates, but the unit of value is the team itself — agents with roles, reports, budgets, and skill bundles. You stop managing tasks and start managing a small company.

The Pattern That Made It Click

The first thing I tried was creating one CEO agent and dumping all my tasks under it. That failed. The agent had no specialization, no context per project, and dozens of unrelated issues to choose from. It froze.

The second thing I tried was creating a flat list of specialist agents — one per skill. That also failed. There was no hierarchy, no delegation, no way to see which agent owned which line of business.

The third thing worked: a four-level org chart. Generalized, the structure looks like this:

CEO
├── COO        — operations, clients, personal life
│   ├── VP Clients
│   │   ├── Account Lead — Client A
│   │   ├── Account Lead — Client B
│   │   └── Partnership Lead — Project X
│   └── Chief of Staff (personal admin)
│
├── CTO        — products, engineering, infra
│   ├── VP Products
│   │   ├── Head of Brand
│   │   ├── Head of Products Group
│   │   │   ├── Product 1 Lead → BE / FE / Designer
│   │   │   ├── Product 2 Lead → BE / FE / Designer
│   │   │   └── Product 3 Lead → BE / FE
│   │   ├── Head of Vertical X
│   │   └── Project Lead — Personal initiative
│   ├── Head of Personal OS
│   └── Engineering Lead
│
├── CFO        — corporate entities, finance, legal
│   ├── Head of Entity 1
│   ├── Head of Entity 2
│   ├── Finance and Compliance
│   └── Corporate Counsel
│
└── Head of Shared Services
    ├── Negotiation Specialist
    ├── Growth Strategist (SEO, GA4, GSC)
    ├── Content Strategist
    ├── Market Research Lead
    └── Research Desk

Around fifty agents in four layers. Each agent reports to one parent. Each agent has its own instructions file. Each agent has its own skill bundle.

This works because delegation only works when there’s somewhere to delegate to. A CEO with twenty direct reports cannot delegate. A CEO with four C-suite leads, who each have their own teams, can.

Projects Are Not Folders. They Are Lives.

The other thing I learned the hard way: a project in Paperclip is a unit of life, not a unit of work.

I started by creating projects per task category. That collapsed. Then I created projects per actual life-line, and it stabilized. The categories that survived for me:

• Active client engagements (one project each)
• Passive client tracking (one project)
• Owned brands and products (one project per product)
• Corporate entities (one project per entity for legal/tax/admin)
• Personal infrastructure (one project)
• Personal life (visa, travel, legal, family)
• Strategic goals like a long-running visa application track
• Research desk for non-attached investigations

Around seventeen projects. Each has a lead agent. Each has its own kanban view.

This sounds bureaucratic. It is the opposite. Without this structure I had to keep all of them in my head every time I sat down to work. With this structure I open one window, choose one project, and the rest disappears until I want to see it.

For an ADHD-shaped brain this is the whole point. The system holds context so I don’t have to.

Labels Are the Horizontal Search

Projects are vertical. Labels are horizontal. The same issue can show up under one project and across many label filters.

What I’m using:

• role: negotiation / growth / content / design / frontend / backend / research / legal / finance / engineering
• type: discovery / delivery / admin / research
• urgent: this-week / this-month
• blocked: awaiting-info / external
• gap: skill-missing

The two most useful in practice are role: and gap:skill-missing. The role tag means I can ask “what’s open for the Negotiation Specialist this week” and get a clean cross-project list. The skill-missing tag means I can see immediately which tasks are blocked because I don’t have the capability locally — about ten percent of my open issues are tagged that way right now, and most of them are corporate or legal work where no agent can help and I need a real lawyer.

Tasks Can Be Assigned to You

Here’s the move that changed how I think about the system. Agents can assign tasks to me.

When an account lead agent needs information only I can provide — a username, an OAuth token, a signature, a phone call — it doesn’t fail and it doesn’t hallucinate the missing input. It marks the issue blocked:awaiting-info and reassigns it to me with a comment explaining what it needs.

This means the system doesn’t pretend it can do everything. It does what it can, and routes the rest to the only entity in the company who can actually walk to the bank — me. Two-way assignment is what turns it from “AI playground” into “operating system for a real life with real obstacles.”

Talking to It Through Claude Code, Not Through the UI

The web UI is great for visual review. But the way I actually work is different: I talk to my CEO agent through Claude Code, in the same one window I always work in.

When I want a status report, I don’t open the kanban. I ask in chat: “what’s open for Chief of Staff this week?” Claude pulls the issues from Paperclip’s REST API, filters by assignee plus status, and gives me the list. When I want to add a task, I describe it; Claude creates the issue, links to project, attaches labels, assigns to the right agent. When I want to wake an agent on a specific issue, I ask Claude to do it.

The UI is witness. The chat is interface. This matters specifically because I can do all of this remotely — from my phone via Claude Code remote-control, from a co-working desk, from anywhere. The system doesn’t tie me to my desk to manage it. It travels.

How Tasks Actually Get Done

This is the part where systems usually fail. The kanban looks pretty, the agents are configured, and then nobody runs anything.

The first time I clicked “wake” on one of my account lead agents, it spawned a Claude Code subprocess via the claude_local adapter, loaded its instructions, found its assigned issues, and went to work. Two hours later it had:

• Set up a working directory with the right folder structure for the engagement
• Read every brief and chat history I had on the situation
• Loaded a relevant negotiation skill from my local skill library
• Produced an analysis document and a draft action message for each subtask
• Produced a cross-cutting review document grading the existing approach against an explicit framework
• Produced a final synthesis with priority order, pattern observations, and concrete next-step recommendations

A handful of issues closed. Several commits. All while I was working in another window on something completely different.

The substance was not generic AI slop. The analysis named specific tactical mistakes I had made and explained why each was a mistake. The review graded existing work against the framework explicitly and explained the gap. The synthesis named patterns I repeat that I would not have surfaced on my own. It was the kind of writeup I would have hired a real consultant to produce.

The Stuff That Doesn’t Work Yet

This isn’t a sales post. Three real limitations I hit:

1. Agent creation is API-only. The CLI cannot create agents (issue #369, still open at the time of writing). I had to script all of my agent creations through the REST API. Not hard, but a sign of immaturity.

2. The first heartbeat run failed for every agent I created via API. Default adapterType is process with no command, which means the daemon tries to spawn a process called nothing. Every issue went “in_progress” → “failed” the moment I clicked it. Fix: PATCH every agent to adapterType: "claude_local" with the same config the auto-created CEO agent had. After that, agents ran cleanly.

3. Daily releases mean breaking changes. The version I’m running today is not the version I’ll be running next week. Pin the version once you have something working.

The bigger limitation Paperclip can’t fix: AI agents will happily produce confident garbage on tasks they aren’t built for. If I waked the Corporate Counsel agent on a complex legal restructuring issue, it would generate a confidently-worded but legally meaningless document. That’s why I tag those issues gap:skill-missing and route them to me instead. The system makes delegation easy. It does not make delegation safe. That guardrail is still on you.

Practical Setup for Claude Code Power Users

The minimum viable path for a personal-OS workflow:

1. Install: mkdir paperclip-workspace && cd paperclip-workspace && npx paperclipai run. Starts on localhost:3100.
2. Open the UI. Let it create your default company. The auto-created CEO uses claude_local adapter — note the config, you’ll copy it.
3. Create projects for each of your actual life-lines. Don’t model task categories. Model lives.
4. Create your agent hierarchy via the REST API. Four levels: CEO, C-suite, Heads/VPs, ICs. POST to /api/companies/<id>/agents with {name, role, title, reportsTo, adapterType: "claude_local", adapterConfig: {...same as CEO...}}.
5. Create labels for role / type / urgency / gap.
6. Dump your todo list. Every task you’ve been carrying becomes an issue. Assign to the right agent. Link to project. Attach labels via PATCH.
7. Click wake on the agents whose work is most defined. Operational tasks (set up workspace, generate report, audit data) work great. Strategic tasks (decide a corporate restructuring) need you in the loop — and the agent can correctly assign those back to you.
8. Pin the version in package.json. Don’t let daily releases surprise you.

Two hours of setup. Then the rest of your operating life moves into one window.

The Real Outcome

I started this experiment with many active projects scattered across as many Claude Code sessions, a Notion that I never opened, and a tasks-md file I forgot to update. I ended with seventy-plus issues across seventeen projects in one local web UI, an org chart of around fifty agents, and a CEO-agent I can ask “what’s open this week” and get a real answer.

The operative shift is not technological. It’s representational. Before, my work existed in my head and got worse every day I didn’t write it down. Now my work exists in a system I can see, query, filter, and delegate from. The cognitive tax dropped by an order of magnitude. The amount of work that actually gets done went up.

If you live in Claude Code 24/7 and your task list outpaces your ability to remember it, install Paperclip this week. Build the org chart. Move the chaos from your head to the system.

The window count goes from N to one. That’s the whole game.

---

Resources

• Paperclip GitHub: paperclipai/paperclip (MIT license, very young, very actively developed)
• Install: npx paperclipai run