Paperclip.ing: What It Is and What Your AI Agents Still Need to Actually Work

Q: What is the difference between Paperclip and Veritos?

Paperclip manages what agents do. Veritos manages what agents know. Paperclip is an orchestration layer for coordinating multiple AI agents. Veritos is a knowledge and skills management layer that keeps rules, skills, and context synchronized across all your projects and teams. They solve different problems and work well together.

Paperclip (paperclip.ing) hit 4,000+ stars on GitHub within its first week. That doesn’t happen unless something genuinely clicks. It solves a real coordination problem for teams running multiple AI agents, and it does it well. But there’s a gap it doesn’t address, one that shows up quietly and gets expensive to ignore. This post covers both.

What is Paperclip.ing?

Paperclip is an open-source orchestration platform for running multiple AI agents as a coordinated company. The tagline is “zero-human companies,” which is provocative, but the real insight is simpler: when you have more than a handful of AI agents, managing them with sticky notes and 20 open tabs doesn’t work anymore.

Think of it like this. Hiring a bunch of freelancers is fine until you realize nobody knows what anyone else is doing, costs are spiraling, and every new task requires you to brief everyone from scratch. Paperclip adds the company layer: org charts, budgets, approval gates, goal alignment, and a heartbeat scheduler that wakes agents up on a schedule to check their work and take the next step.

Here’s what you actually get:

Org charts for agents: define roles (CEO, CTO, developer, marketer, support lead, whatever) and assign them to agents
Budget controls: each agent has a monthly spend cap, with warnings at 80% and a hard stop at 100%, so no runaway API bills
Persistent state: agents pick up where they left off across restarts, rather than losing all context and starting cold
Goal alignment: every task carries its full goal ancestry, so agents know why they’re doing something, not just what
Governance: big decisions require board-level approval, bad changes can be rolled back
Full audit trail: every conversation is logged, every tool call traced

It works with Claude Code, OpenClaw, Codex, Cursor, Bash scripts, or any HTTP-reachable agent. It’s self-hosted, MIT licensed, and boots with a single npx paperclipai onboard --yes.

For teams moving from “a few scripts with Claude” to “a proper multi-agent system,” Paperclip is a genuinely good answer to the coordination problem.

The problem Paperclip doesn’t solve

Here’s where it gets interesting.

Paperclip is excellent at managing AI agents. It knows where each agent is, what it’s supposed to be doing, how much it’s spending, and whether it’s making decisions it shouldn’t be making unilaterally.

What Paperclip doesn’t do is manage the knowledge and skills those agents need to do their jobs well.

When an agent fires up inside Paperclip and picks up a task (write a feature, draft a campaign brief, handle a support ticket, research a market), the quality of what it produces depends almost entirely on what context and skills it has available. Specifically:

What tone and style should it write in?
What’s your process for this kind of task?
What has already been decided and shouldn’t be re-litigated?
What does it need to know about your product, your customers, your internal tools?

In Claude Code, this context lives in .claude/ folders: rules, skills, subagent configs, MCP definitions. These files are what turn a generic AI into something that actually understands your team, your workflows, and how you work.

A coding agent without proper skills will suggest the wrong patterns. A marketing agent without brand guidelines will write off-tone copy. A support agent without product context will give vague answers. The agent is only as good as the skills and context it’s been given.

And here’s the thing nobody mentions until they’ve actually tried to scale this: managing those skill files across multiple agents, projects, and teams is its own problem.

What happens when agents multiply

This is something we ran into at Jumax before we built Veritos. Once you’re running agents across more than a handful of projects, the skill and context files multiply fast.

Your coding agent has one set of skills. Your marketing agent has another. Your support agent has its own. Each was probably set up at a different time by a different person, and over time they drift in all directions.

What happens:

Skills go stale. The marketing agent is still writing in a tone you moved away from six months ago.
Agents give inconsistent output. Same kind of task, different agent or project, completely different result.
Somebody updates a skill for one agent and forgets to carry it across to the others.
Nobody knows which agents have the “current” version of anything.
A new teammate sets up an agent from an old template and it runs with outdated context for weeks before anyone notices.

We hit that last one with a client project. They’d been working with outdated .claude context for days. Output looked off, the agent was following old patterns. By the time we figured out what was happening, more time had been wasted than the original problem was worth. All because a skill file had quietly drifted out of date.

Paperclip can coordinate a hundred agents. But if those agents are all working with inconsistent, outdated skills and context, you’ve built a well-organized company with a bad knowledge base.

How Veritos fits into this

This is the gap Veritos fills. Where Paperclip is the org structure layer for your AI company, Veritos is the institutional knowledge layer.

The basic idea: your team creates and manages all your AI resources (rules, skills, subagent configs, MCP definitions) in a central Library. Skills for how your coding agents should write code. Guidelines for how your marketing agents should communicate. Workflows for how your support agents should handle escalations. All of it in one place, versioned, and connected to every project that needs it.

When something changes, Veritos automatically opens pull requests in every connected repository to update the relevant files. Your team reviews and merges. Standard GitHub workflow, same as any other change.

Under the hood, Veritos:

Stores all your AI resources in one versioned Library: one place to update, not scattered across every project
Connects to your GitHub repos via a GitHub App: no special infrastructure, it uses what you already have
Writes skills and rules into the right folders: agents find them exactly where they expect
Tracks what’s synced via a lockfile: you always know which version of each skill is live in which project
Automatically opens PRs when something changes: updates go through review, not Slack messages

Every agent, whether spinning up inside Paperclip or running locally in someone’s editor, gets the same skills and context, kept current without anyone manually copying files around.

Paperclip + Veritos: how they work together

The simplest way to put it:

Paperclip answers: Which agent is doing what, when, and how much is it spending?

Veritos answers: What does every agent know, and is it current?

Here’s how it fits together in practice:

You set up your Paperclip org: define roles, assign agents, set budgets.
You build out your Veritos Library: coding standards, brand voice guidelines, support playbooks, research frameworks, product context, whatever your agents need to do their jobs well.
When Paperclip wakes up an agent to work on a task, that agent has the current skills and rules in its project folder, which Veritos keeps synchronized.
When something changes (new brand guidelines, updated process, a postmortem leads to a better workflow), you update it in Veritos. PRs go out to every connected project. Everything stays aligned.
Paperclip logs what the agent did. Veritos makes sure the agent had the right knowledge and skills to do it correctly.

The two tools aren’t competing. Paperclip handles the management side. Veritos handles the knowledge side. They work well together.

Context is the bottleneck nobody names

Paperclip took off because it names a problem people actually recognize: coordinating multiple agents at scale is genuinely hard. It gave that problem a shape and a solution.

Agent knowledge management is the same kind of problem. It surfaces more quietly, usually as “that agent keeps doing it wrong” or “why does this one write so differently” rather than anything dramatic. But the root cause is the same: agents are running on skills and context that nobody is actively maintaining.

If you’re running a single agent on one project, you’re not there yet. But if you’re scaling up, multiple agents, multiple roles, a team of people setting things up at different times… drift is coming. It’s just a matter of when.

Getting started

If you’re already using Paperclip and seeing inconsistency in how your agents perform across different projects or roles, that’s almost always a knowledge problem. The fix is a central Library that keeps skills and context in sync everywhere, so every agent works from the same current source. That’s what Veritos does, and it’s free to start with, no credit card required.

Get started free →

If you’re not using Paperclip yet but thinking about scaling your AI agent setup, their documentation is worth reading. The architecture is sound.

FAQ

What is Paperclip.ing?

Paperclip.ing is an open-source orchestration platform for running multiple AI agents as a company. It provides org charts, budget controls, governance, goal alignment, and persistent state management for AI agent teams. It’s self-hosted, MIT licensed, and works with Claude Code, Cursor, OpenClaw, Codex, and any HTTP-reachable agent.

What problem does Paperclip solve?

Paperclip solves the multi-agent coordination problem. When you have 10 or 20 AI agents running in parallel across different roles and projects, it’s easy to lose track of what each one is doing, rack up unexpected API costs, or have agents making decisions they shouldn’t be making alone. Paperclip adds a management layer that handles scheduling, budgets, approvals, and audit trails.

What is the difference between Paperclip and Veritos?

Paperclip manages what agents do. Veritos manages what agents know. Paperclip is an orchestration layer for coordinating multiple AI agents. Veritos is a knowledge and skills management layer that keeps rules, skills, and context synchronized across all your projects and teams. They solve different problems and work well together.

How does Veritos help with AI agent skills and context?

Veritos gives your team a central Library to store and manage everything your agents need: skills, rules, workflows, brand guidelines, product context, subagent configs, MCP definitions. When something changes, Veritos automatically opens pull requests in every connected repository. Every agent, in every project, gets the same up-to-date skills without manual copying.

Does Veritos work with Paperclip?

Yes. Paperclip fires up agents that work in your projects. Those agents rely on the skills and context files in the project folder. Veritos keeps those files current and synchronized. You can run Paperclip for orchestration and Veritos for knowledge management. They operate at different layers and don’t conflict.

Why do AI agents give inconsistent output across different projects or roles?

Usually because the skills and context files have drifted. Set up at different times, updated sporadically, never properly synchronized. Agents are only as good as the knowledge they’re given. When that knowledge drifts, output drifts. Veritos treats agent skills like code: versioned, centralized, and automatically pushed out via PRs whenever something changes.

Built by Julian Pomper and Max Gierlachowski in Vienna. We build production software at Jumax and we built Veritos because we needed it ourselves.