Paperclip Blueprints: Generate Paperclip companies from a markdown brief

Paperclip is an open-source platform for orchestrating multi-agent companies. It gives agents org charts, budgets, approval gates, and task tracking, acting as a management layer for an AI workforce. It is powerful, but it takes real work to set up. A single company is not one config file. It is dozens of markdown files covering identity, agent definitions, projects, operations rules, and governance.

Writing all of that by hand is slow, and the result tends to drift. Setting up more than one company means re-deriving the same scaffolding each time and hoping it stays consistent across every file. That is where small errors appear. A goal in one file is really a task. An agent's mandate contradicts the org rules two files over. None of it throws an error, so the company simply runs a little off from what was intended.

I needed to set up several Paperclip companies, and doing it by hand kept producing these inconsistencies and burning hours. The patterns for doing it well already existed in Paperclip's community guides. Applying them by hand, the same way every time, was exactly the kind of work that should be automated.

That's why I built paperclip-blueprints.

From a Markdown brief to a deployable Paperclip company bundle

The useful realization was that the right input is not config at all. It is a brief.

When you describe a company to another person, you do not list dozens of config files. You say what it is, what it is emphatically not, what outcomes it is chasing, and the one north star everything serves. That is the actual source of truth. The org structure, the agent roles, and the operations rules are all derived from it. So the input should be the brief, and the structure should follow from it.

The tool takes a markdown brief describing the company: identity, a "we are / we are not" section, goals stated as outcomes, and a north star. It generates a complete, deployable Paperclip bundle, ready to import. That includes a COMPANY.md identity file, an auto-generated README with a mermaid org chart, operations rules, and a directory per agent with its role, mandate, and heartbeat. All of it conforms to Paperclip's import schema.

How Paperclip Blueprints generates and validates the bundle

The pipeline runs in four stages: brief, identity, org structure, and validated bundle. The first three stages generate the files. The fourth validates them before import, so structural problems surface before the agents are running on them. Some validation also happens at input time. The tool enforces a goal-as-outcome rule, for example, which catches the common mistake of writing a one-off task where a persistent outcome belongs.

Generation uses Claude Opus 4.7 and Sonnet 4.6. The heavier model handles the structural reasoning, and the lighter one handles the rest.

The generated bundles encode Paperclip's documented best practices and reference patterns by default. That includes goal-as-outcome, the "we are / we are not" framing, sensible span-of-control, and a coherent governance posture. None of it has to be remembered and applied each time, because it is built into the output. The result is not only faster than hand-writing the files, it is better structured than the bundles I was producing by hand.

I use this tool to spin up companies, and I run it in production for my own work.

Try Paperclip Blueprints on your own Paperclip company

paperclip-blueprints is MIT licensed and public: github.com/Grolea-HQ/paperclip-blueprints.

It's a Python CLI. You'll need Python 3.11+, uv, an Anthropic API key, and a Paperclip instance to import into. The quickstart:

git clone https://github.com/Grolea-HQ/paperclip-blueprints.git
cd paperclip-blueprints
uv sync

export ANTHROPIC_API_KEY=sk-ant-...

cp examples/input-template.md examples/my-company-brief.md
# edit the brief: identity, north star, goals, constraints

uv run blueprints generate \
  --input examples/my-company-brief.md \
  --output examples/generated-companies/my-company/

Then import the generated directory through Paperclip's import flow.

A note on cost. Generation runs on the Anthropic API rather than a Claude subscription, so each bundle costs roughly $1 to $3 in API credits and takes three to eight minutes depending on company complexity. An eleven-agent company runs about $1.50. The tool prints a cost summary after each run.

This is a v0.1 release. The brief-to-bundle path works, generated bundles import successfully into a real Paperclip instance, and every bundle is schema-validated before import. The defaults reflect Paperclip's documented best practices, and the brief is where you specify what is particular to your company. If you are running agents on Paperclip and are tired of hand-writing the scaffolding, it is worth ten minutes.

If you try it, I'd like to hear how it goes.

I'm building AI-native operations at Grolea Oy. If this is the kind of thing your team is working through, get in touch.