Paperclip: Run a Small AI Agent Team (Claude Code + Codex) Without the Chaos

Video authored by the channel shown, not by IANIA; all rights belong to the creator. Transcript and summary generated automatically; the original-language content is preserved.

Original language: English

Original video: Paperclip: Run a Small AI Agent Team (Claude Code + Codex) Without the Chaos · Channel: AICodeKing · 10:21 · Watch on YouTube

Topics: AI agents, Enterprise AI applications, Task and workflow automation, Claude Code, AI models

Summary

Paperclip is an open-source app for organizing teams of AI agents, with tools for assigning tasks, coordinating handoffs, tracking progress, and reviewing work. The video walks through setting up a small agent team to build a notes app, emphasizing clear goals, limited scope, human approval, and concrete checks of the finished work. It also explains budgeting, agent wake-ups, recurring routines, shared skills, and service permissions. The presenter recommends trying Paperclip when coordinating several agents, while cautioning that it may be unnecessary for short tasks handled by one agent and that human oversight remains important.

Key points

Paperclip organizes AI agents; the connected agents still perform the coding and other assigned work.
It supports multiple agent adapters, allowing different tools to be used for implementation and review.
A small team can begin with a coordinator, a coding agent, and a reviewer rather than a large hierarchy.
Tasks can include briefs, comments, progress updates, and blockers; isolated workspaces can help separate code changes.
The example setup uses a notes app with persistent storage and explicit limits on scope.
Human approval can be used for plans, proposed hires, review handoffs, and final completion.
Spending can be tracked and budgets set, but reported usage and work already in progress may delay a hard stop.
Heartbeat intervals are off by default for new agents; routines can schedule recurring jobs.
Shared skills and service connections help standardize instructions and control access, though tool gateway controls do not govern every shell command.
Paperclip is most relevant when several agents need coordination; its structure does not replace good goals or close review.

Chapters

Start	Chapter	Summary
00:01	What Paperclip does	The presenter introduces Paperclip as a way to organize agent roles, tasks, and handoffs, and explains how it sits above the connected coding tools.
02:03	Organization, delegation, and task setup	The video describes Paperclip’s organization model, task workflow, and workspace isolation before outlining a small notes-app project.
04:08	Setting up and reviewing a small agent team	The presenter covers local installation, configuring agents, defining project scope, and using review and approval stages.
06:44	Costs, routines, skills, and permissions	The video discusses budgets and usage limits, agent heartbeats, recurring jobs, shared skills, and the boundaries of tool permissions.
09:19	Who should use Paperclip	The presenter recommends Paperclip for people coordinating multiple agents while stressing that human judgment and verification remain essential.

Quotes

And that is where Paperclip comes in. — 00:32

A coordinator and a couple of agents with clear jobs would be a much more sensible starting point. — 02:35

An agent saying it finished is only the start of reviewing its work. — 06:14

Personally, I’d run one small task, look at the usage, and then decide how much room to give each agent. — 07:15

A CEO title doesn’t make an agent good at deciding what to build. — 09:50

Concepts and entities

Paperclip, Claude Code, Codex, Gemini CLI, Cursor, MCP, Skill Studio, heartbeat, worktree, MIT License

Full transcript (original language)

00:01 [music] Hi, welcome to another video. Just before we start the video, I have recently posted a video on the membership about how I am using Opus 5.5 and it is almost a tutorial of how to get the best stuff out of it. I am also going to become more active on the membersonly video now as well. So, if you like what I do and want to support the channel and also get some perks along the way, then I’d highly recommend you to hit the join button and choose a level. The exclusive videos are available on all the tiers from bronze

00:32 and above. Now back to the video. So running one AI coding agent is pretty straightforward. You give it a task, check what it does, and ask it to fix whatever it missed. But once you have clawed code building something, codeex reviewing it, and another agent handling research, you also have to manage the handoffs. Someone has to keep track of the goal, explain who’s responsible for what, and check how much all of this is costing. And that is where Paperclip comes in. It’s an open- source app for managing teams of AI agents. You can

01:02 give those agents roles, organize their work around projects, and follow what they’re doing from one dashboard. It even has an org chart. So yes, your coding agent can now have a manager. Now, the whole idea of running an AI company sounds exciting, but personally, I’m more interested in whether this can make a small team of agents useful without creating even more work for the person managing them. So, let’s get right into it. So, Paperclip sits above the agents you connect. Clawed code or codeex still does the actual coding. Paperclip handles the organization around that work. That includes

01:32 assigning tasks, passing work between agents and keeping a record you can come back to. It supports adapters for tools like clawed code, codeex, Gemini, CLI, cursor, open code, and pi. There are also integration paths for custom processes and HTTP services. An adapter is simply the connection that lets Paperclip start an agent and collect what happened during its run. You still need to configure the runtime you’re using and I like that flexibility. For example, I might want one agent for implementation and another for reviewing the changes. I can choose their tools separately instead of

02:03 building the entire workflow around one provider. Now, the organization model is quite interesting. You create a company which the current interface calls an organization and that gives your team a place to work. You can then add a goal and connect projects to what you’re trying to achieve. The documented setup starts with a CEO agent. Its job is to read the goal, propose a plan, and delegate work. Other agents can report to it, or you can build a larger hierarchy with managers and workers. You sit above that as the person making the

02:35 final decisions. Although, I would keep this small initially if I’m building a basic app. I probably don’t need six management agents discussing what the front-end agent should do. A coordinator and a couple of agents with clear jobs would be a much more sensible starting point. Paperclip’s delegation workflow lets that coordinator create tasks and assign them to its reports. Agents post updates as they work and blockers can come back up the chain so you have a way to follow how the original request turned into smaller pieces of work. Now those tasks are a big part of the

03:06 experience. Each issue can hold the brief comments and progress updates. You can filter work by things like status or assigne and open a blocked task to see what it needs. There is also a checkout mechanism that prevents competing runs from claiming the same task. That’s useful, but two separate tasks can still involve the same code. You need to think about how their workspaces are configured as well. Paperclip has an experimental isolated workspace feature for that. When enabled and configured, it can give a task its own git work tree and branch that gives coding changes a

03:37 separate working copy, although you still need to review and combine the changes afterwards. Now, let’s walk through how I’d set up a small example. Let’s say we want a notes app where you can create a note, edit it, delete it, and keep your notes after refreshing the page. That’s a specific result we can check without turning the first experiment into a massive project. First, you’ll need node version 24.11 or newer. For the quick local setup, open your terminal and run npx paperclipip AI at latest onboard-s. Paperclip AI is written as one word in

04:08 the command, and I’ll leave the exact command with the links below. that accepts the default setup and starts paperclipip locally. It uses an embedded Postgrql database, so you don’t have to set up a separate database server for this first run. You’ll also need the agent runtime you want to connect. If you’re using a local cloud code or codeex adapter, make sure that CLI is installed and authenticated on the machine running paperclip and you don’t necessarily need to buy separate API access. The adapter documentation supports existing subscription login for these tools as well as API key setups.

04:40 Which account gets used depends on the adapter and its configuration. So check that before you start running tasks. Once you’re in paperclip, give the organization a name and configure the first agent. Choose its adapter model and working directory. Then use test environment to check the connection. I do that before adding the rest of the team. If the first agent can’t run, adding four more is just going to give you four more things to troubleshoot. Then I’d add the goal for our notes app and make the scope clear. something like build a local notes app with persistent storage, include tests for the main

05:11 actions, and provide instructions for running it. I’d also say that accounts and payments are outside the scope of this first version. For the team, I’d use the coordinator to organize the work, a coding agent to implement it, and a review agent to check the result. Those are example roles. You can choose different models or tools depending on what you already have access to. Now, when the coordinator proposes a strategy, I’d read it before approving. If it wants to build a back-end service and an authentication system for this tiny demo, I’d request a revision. Keep

05:43 the first version local and focus on the behavior we asked for. The approval flow also covers proposed hires. You can inspect the role in configuration before adding another agent and request changes if the proposal doesn’t make sense. So, the team can suggest what it needs while you still decide whether that is worth doing. For the implementation task, I’d configure a review stage and have the reviewer check the actual app. Can it create and edit notes? Does deleting one remove the right item? Does refreshing preserve the data? Those checks give the reviewer something concrete to judge. Paperclip can enforce that review step

06:14 when the coding agent tries to close the task. It routes the issue to the reviewer and requested changes can send it back to the original agent. You can also configure a final approval stage. I think this is one of the more useful features here. An agent saying it finished is only the start of reviewing its work. For this example, I’d want to see the app running and inspect the test results before calling it done. That’s the workflow I’d use for a demo. The quality of the finished app still needs to be tested. Now, let’s talk about the cost because this is where a team of agents can get expensive pretty quickly. Paperclip itself is free to self-host and uses the MIT license. Your model

06:44 usage, existing subscriptions, and any hosting costs are separate. Connecting several agents doesn’t give you unlimited access to the services behind them. You can track reported spending and set budgets at the company agent or project level. There are warning thresholds and configurable hard stops so you can decide where work should pause instead of letting everything keep running unchecked. But there is a detail here. Enforcement uses recorded spending and usage reporting or work already in progress can delay the stop. So I wouldn’t treat a budget setting as a

07:15 guarantee that the provider bill will land exactly on that number. Personally, I’d run one small task, look at the usage, and then decide how much room to give each agent. The amount you spend will depend on the models and how much work they do. A reviewer going back and forth with an implement also adds usage, even if the app itself is fairly simple. And this brings us to heartbeats. Paperclip uses them to wake agents and let them work. Assignments and comments can trigger runs, and you can also configure an interval. Timer heartbeats are off by default for new agents, which

07:47 I think is a sensible choice. If an agent wakes every few minutes just to discover there is nothing to do, you’re creating activity without getting much out of it. I’d leave it waiting for work unless there’s a specific reason it needs to check something regularly. For recurring jobs, there are routines. For example, you could have an agent prepare a weekly summary of completed work or check incoming issues each morning. You define the job, assign an agent, and add a schedule or web hook trigger. Each execution gives you tracked work you can inspect afterwards. That’s a feature I’d probably use quite a bit. With a recurring report, I want to know whether

08:17 it ran and where the result went. Having that attached to a task makes it easier to follow up when something is missing. Now, there are shared skills as well. You can write a procedure once and make it available to the agents that need it. For our notes app, that could be a review checklist explaining what evidence to collect before approving a change. Skill Studio lets you edit those instructions, test them with saved inputs, inspect the outputs, and restore earlier versions. So, if a change to your checklist makes the reviews worse, you have a way to compare the behavior

08:49 and go back. I like this more than repeatedly pasting the same long instructions into different chats. Although the instructions still need to be good, sharing a vague checklist with every agent will just spread the same confusion around the team. Paperclip also has service connections, including app tools and custom MCP integrations. For supported tool connections, you can control which agents get access and set actions to allowed ask first or off. One distinction matters here. Those action controls apply to calls going through Paperclip’s tool gateway. They don’t automatically control every shell command a coding agent can run. So, I’d check the runtime permissions and

09:19 credentials as part of setting up the team, especially before giving it access to a real project. Now, who would I recommend this to? If you already have several agents working on related tasks and you’re spending time coordinating them, I think Paperclip is worth trying. The task history and review handoffs are the parts I’d focus on. First, if you mostly use one coding agent for short requests, you might find the organization setup unnecessary. I wouldn’t create an entire company structure just to rename a few variables. Start with a task that actually needs coordination and see whether the extra structure helps. And I’d take the autonomous company idea with a grain of salt. A CEO title

09:50 doesn’t make an agent good at deciding what to build. You still need a useful goal, sensible instructions, and someone willing to look closely at the output. Overall, I like the direction of Paperclip. It’s open source. It works with a range of agents, and it gives you a place to manage work that would otherwise be scattered across sessions. For me, the first test would be whether that small notes app team can produce a result I can verify at a cost I’m happy with. If it does, then I’d start giving it more responsibility. Overall, it’s pretty cool. Anyway, let me know your

10:21 thoughts in the comments. If you like this video, consider donating through the super [music] thanks option or becoming a member by clicking the join button. Also, give this video [music] a thumbs up and subscribe to my channel. I’ll see you in the next one. Until then, bye. >> [music] [music]