Paperclip agents burn ~20,000 tokens before reading a task. Let's cut the bloat.
Most of what an agent reads before working a task is dead weight. One config change and a new approach to agent overrides can cut the bill by over 80%.
Every time a Paperclip agent wakes up, it reads about 20,000 tokens of context before it touches a single task. Most of that context is dead weight. For a five-agent C-suite running at Paperclip’s 1-hour default, that’s roughly $213 a month on Sonnet 4.6, $355 on Opus 4.6, or $479 on Opus 4.7, spent on content the agents never use.
This is a fix.
Who this is for
Anyone evaluating Paperclip for marketing operations. If you have a technical partner or ops person on the team, forward this to them. If you are comfortable in a terminal, read on.
Fair warning: this gets into the weeds.
Token counts, config files, shell scripts. It’s a long read, but an agent that burns over 20,000 tokens of context before reading a single task is an agent eating into your capacity for actual work. Cutting this overhead lowers the bill and gives you sharper output from the tokens you’re already paying for.
What is Paperclip
Paperclip is an open-source AI agent orchestration platform, MIT-licensed. Think of it as the operating system your AI employees run on. You define agents (a CEO, a CMO, a CTO, etc.), give them roles and instructions, and Paperclip handles scheduling, memory, tool access, and coordination. Each agent “wakes up” on a heartbeat, checks its tasks, does its work, and goes back to sleep.
Built by the team at PaperclipAI, it’s model-agnostic. It ships with adapters for Claude Code, Codex, Cursor, and more. If an AI tool can receive a heartbeat, Paperclip can orchestrate it.
How Paperclip fits in the landscape
If you’ve been following the AI agent space, you know Paperclip isn’t the only option. A few common approaches:
- Agent frameworks (CrewAI, AutoGen, LangGraph) let developers build multi-agent workflows in code. Powerful but engineering-heavy. Build-your-own, not plug-and-play.
- No-code and low-code platforms (Relevance AI, Lindy) offer drag-and-drop agent builders for business users. Easier to start, limiting when you need depth or cross-stack operation.
- DIY prompt chains and Zapier or Make automations work for simple use cases. Coordination between agents (blocking dependencies, shared memory, governance) turns into duct tape fast.
Paperclip sits in a distinct spot: the structure of a real org chart (roles, delegation, approvals, budgets) without the scaffolding burden. Open source means you can read the code, extend it, and avoid lock-in.
For marketing teams specifically, Paperclip is the backbone that lets you run an always-on AI marketing org without babysitting every prompt or workflow.
Three use cases for growth marketing
1. Always-on campaign operations. A Paperclip CMO agent monitors campaign performance across channels, flags underperformers, drafts copy variations, and coordinates with a CRO agent on lead quality. Nobody manually triggers anything. Your team wakes up to a prioritized action list, not a dashboard to interpret.
2. Cross-functional coordination at machine speed. Growth doesn’t happen in a silo. Your CMO agent needs instrumentation from a CTO agent, pipeline data from a CRO agent, strategic sign-off from a CEO agent. Paperclip handles that coordination natively. Agents create tasks for each other, block on dependencies, and request board approvals. It mimics how a real executive team operates, at the speed of API calls.
3. Scalable content and channel execution. Instead of one marketer context-switching across SEO, email, paid, and social, you spin up specialists for each channel. Each agent carries its own context (audience segments, brand voice, benchmarks) and operates inside the guardrails your CMO sets. Need a new channel? Hire a new agent. Minutes, not months.
Why this matters right now
Anthropic’s user base has grown dramatically, and with it the pressure on token usage. Even users on higher-tier Max plans have reported hitting rate limits and usage caps more than they expected.
An agent that burns over 20,000 tokens of context before reading a single task is an agent eating into your capacity for actual work.
If you’re running a multi-agent org on Claude, every wasted token costs twice: once on your bill, once against your rate-limit ceiling.
Anatomy of a vanilla Paperclip heartbeat
Here’s what gets injected into a fresh CEO agent on every wake.
Layer 1: Baseline skills (auto-injected, every agent, every wake)
| Skill | Lines | ~Bytes | ~Tokens | What it contains |
|---|---|---|---|---|
paperclip | 541 | 35,871 | ~10,700 | Auth, heartbeat procedure (9 steps), scoped-wake fast path, execution-policy wakes, issue dependencies, board approvals, critical rules, comment style, planning, endpoints table, plus CEO and manager-only sections: project setup, company skills workflow, routines, OpenClaw invites, instructions-path management, company import/export, issue search, self-test playbook |
paperclip-create-agent | 144 | 5,351 | ~1,600 | Hiring workflow: discover adapters, compare configs, draft hire payload, submit to governance, handle approval |
paperclip-create-plugin | 101 | 3,068 | ~900 | Plugin scaffolding guide: scaffold CLI, manifest conventions, UI slots, verification steps |
para-memory-files | 104 | 3,978 | ~1,200 | PARA method memory system: knowledge graph, daily notes, tacit knowledge, qmd semantic search, planning files |
| Baseline total | 890 | ~48KB | ~14,400 |
Layer 2: External bundle (agent-specific, loaded on wake)
The CEO gets a 4-file external bundle (instructionsBundleMode: "external" or internal $AGENT_HOME files):
| File | Lines | ~Tokens | Purpose |
|---|---|---|---|
AGENTS.md | 54 | 960 | Identity, delegation routing, memory, safety |
HEARTBEAT.md | 82 | 1,120 | Per-cycle execution checklist |
SOUL.md | 33 | 780 | Persona, voice, strategic posture |
TOOLS.md | 3 | 26 | Placeholder |
| Bundle total | 172 | ~2,900 |
Layer 3: Claude Code system prompt
About 5,000 tokens of Claude Code runtime instructions, not Paperclip-controlled. This baseline varies with the MCP tools you have installed.
Total per-wake cost (vanilla CEO)
| Layer | ~Tokens |
|---|---|
| Claude Code system prompt | ~5,000 |
| Baseline skills (4 SKILL.md files) | ~14,400 |
| CEO external bundle (4 files) | ~2,900 |
| Total before any work | ~22,000 |
For a standard IC agent (CMO, CRO, CTO) with the default 3-line AGENTS.md and no external bundle, the total is about 19,400 tokens. Nearly all of it is baseline overhead.
Where the waste is
Not all baseline content is waste. The heartbeat procedure, critical rules, and comment style are essential. But:
Content no IC agent ever uses (~40% of paperclip/SKILL.md)
| Section | Lines | Who needs it |
|---|---|---|
| Project Setup Workflow | 13 | CEO or manager only |
| OpenClaw Invite Workflow | 26 | CEO only, and only if using OpenClaw |
| Company Skills Workflow | 11 | Manager only |
| Routines | 11 | Rare; already lazy-loads references/routines.md |
| Setting Agent Instructions Path | 27 | Manager only |
| Company Import/Export | 24 | CEO or board only |
| Searching Issues | 10 | Niche; one endpoint in the table suffices |
| Self-Test Playbook | 37 | Dev and validation only |
| Endpoint table (manager rows) | ~30 | Manager only (routines, skills, import/export, project setup) |
| Subtotal | ~189 | ~2,800 tokens wasted per IC wake |
Skills no IC agent ever calls
| Skill | Lines | Tokens | Who needs it |
|---|---|---|---|
paperclip-create-agent | 144 | 1,600 | CEO, and only when hiring |
paperclip-create-plugin | 101 | 900 | Nobody at runtime. Plugin dev is a developer task. |
para-memory-files | 104 | 900 | Only if your memory model isn’t PARA. Keep as-is for default installs; stub when you’ve got a repo-based or custom memory convention. |
| Subtotal | 349 | ~3,400 tokens wasted per wake |
Duplication in external bundles
A common mistake: copying the PARA memory reference or the full heartbeat procedure into your custom AGENTS.md or MEMORY.md. Since baseline skills are always injected, anything you repeat in your external bundle is loaded twice.
Six best practices
1. Understand the injection model
Paperclip injects skills in this order:
- Baseline skills (4 SKILL.md files). Hardwired,
required: true, cannot be opted out. - Company skills (from
desiredSkills). Opt-in per agent. - External bundle (from
instructionsBundleMode). Your custom agent files.
Your external bundle should complement the baseline, not repeat it.
2. Never duplicate baseline content in your bundle
Bad:
# MEMORY.md
## Three Memory Layers
### Layer 1: Knowledge Graph ($AGENT_HOME/life/ -- PARA)
... [94 lines copied from para-memory-files/SKILL.md]Good:
# MEMORY.md
Memory is handled by the `para-memory-files` skill (auto-injected).
Your seed entities: [list specific to your company]3. Use skill-precedence directives
Tell your agents which baseline skills to prioritize vs ignore. Add this to your external bundle’s AGENTS.md:
## Skill Precedence
Four baseline skills are auto-injected on every heartbeat. This bundle
is the source of truth for how you operate. The baseline skills are
reference material only:
- `paperclip`: use as API reference when you need an endpoint.
Don't re-walk its heartbeat procedure from scratch each wake.
- `para-memory-files`: [use or ignore based on your setup]
- `paperclip-create-plugin`: ignore (plugin dev is not a runtime task)
- `paperclip-create-agent`: use only when explicitly tasked with a hireThis doesn’t reduce injection size, but it reduces the agent’s tendency to reprocess full skill text on every wake, saving output tokens and tool calls.
4. Use the baseline-override pattern for real cuts
Since baseline skills are required: true, the only way to reduce what’s actually injected is to replace the SKILL.md files in the installed npm package. Details in the next section.
5. Tune heartbeat cadence to match the work
Paperclip’s default interval is 1 hour. For most roles that’s far too tight. See the dedicated section below; this is the single biggest lever in the post.
6. Keep your external bundle under 200 lines total
The bundle is loaded every wake alongside the baseline. A 500-line AGENTS.md is 500 lines your agent processes before reading a task. Targets:
| File | Target | Purpose |
|---|---|---|
| AGENTS.md | < 80 lines | Identity, routing, skill precedence, what you do and don’t do |
| SOUL.md | < 40 lines | Persona and voice (unlikely to need more) |
| HEARTBEAT.md | < 60 lines | Company-specific supplements only. Don’t repeat the baseline procedure. |
| TOOLS.md | < 20 lines | Quick-reference table of available tools |
| MEMORY.md | < 30 lines | Memory model pointer. If not using PARA, say so in 5 lines. |
Heartbeat cadence
Token count per wake is one factor. Wakes per day is the other, and it’s where the real money hides.
Paperclip’s default heartbeat interval is 1 hour (intervalSec: 3600). That’s 24 wakes per agent per day, or 120 total for a 5-agent org. At ~19,700 tokens per vanilla wake, you’re burning 2.36M tokens a day before the override pattern even enters the picture.
Most agents don’t need to wake every hour. A CEO doing weekly readouts and backlog prioritization gains nothing from 24 hourly checks against a mostly-empty inbox. A CMO planning campaign cadence doesn’t either. I’ve advised clients to run their C-suite at a 6-hour interval (intervalSec: 21600). This gets you significant cost savings and with 4 wakes/day, nothing important has been missed.
The math, same 5-agent org, vanilla baseline (no overrides applied):
| Cadence | Wakes/agent/day | Wakes/day total | Tokens/day | Sonnet 4.6 /mo | Opus 4.6 /mo | Opus 4.7 /mo |
|---|---|---|---|---|---|---|
| Default (1h) | 24 | 120 | ~2.36M | ~$213 | ~$354 | ~$478 |
| Tuned (6h) | 4 | 20 | ~394K | ~$35 | ~$59 | ~$80 |
| Savings | ~$178/mo | ~$295/mo | ~$398/mo |
That’s roughly 5x the monthly savings of the baseline-override pattern, and it takes one config change rather than a fork-and-rebase cycle on every Paperclip upgrade. Combine both levers and you can cut the total bill by more than 80 percent.
What to set per role
A 6-hour blanket is the right opening move. The next refinement is per-role tuning, since not every agent has the same responsiveness needs. A rough starter for a standard 5-agent C-suite:
| Role | Interval | Notes |
|---|---|---|
| CEO | 6h | Owns approvals. Needs to unblock ICs within a day. |
| CMO | 8h | Cyclical campaign planning. Tighten to 4h during live launches. |
| CRO | 6h | Pipeline review, forecast hygiene, deal oversight. |
| CTO | 8h | Review and coordination. Tighter only during active incidents. |
| Specialists (Analytics, Email, SEO) | 12h | Reporting is daily-at-most. |
The CEO is your throttle. Keep the CEO at or faster than the fastest IC. If the CEO wakes slower than the C-suite it serves, approvals back up and the whole org stalls. Rare but easy to get wrong.
Default long, tighten on evidence. Start every new agent at 12h. Only shorten when you can point to a specific reason: queue depth growing faster than the agent can process, missed SLAs, bottlenecked approvals.
Event-triggered wakes beat polling
The table above treats heartbeat as a polling loop. For anything with external triggers (new lead, new ticket, Stripe dispute, inbound Slack message), polling is the wrong tool. Paperclip has first-class event wakes that fire outside the scheduled heartbeat.
Layer 1: automatic intra-Paperclip wakes. These fire for free, no setup:
| Event | Who wakes |
|---|---|
| Comment on your task | Task’s assignee |
| @-mention in a comment | Mentioned agent |
| All blockers on your task clear | Task’s assignee |
| All child tasks finish | Parent’s assignee |
| Approval you requested gets decided | Requester |
Your CRO doesn’t need tight polling to catch comments on their deals: those already wake them. The scheduled heartbeat is only there to catch work nobody explicitly pinged them about.
Layer 2: webhook triggers from outside systems. This is how HubSpot, Stripe, Slack, or any webhook-emitting service wakes the right agent. Rough setup:
- Create a routine for the agent that should respond.
- Add a webhook trigger:
POST /api/routines/:routineId/triggerswith{ "type": "webhook" }. You get back apublicIdand a signing secret. - External system fires it:
POST /api/routine-triggers/public/:publicId/firewith your event payload, signed with the secret. - Agent wakes with
PAPERCLIP_WAKE_REASONset, reads the payload, does the work, exits.
Stacked example: a CMO on campaign regression alerts.
- 8h base heartbeat (cyclical campaign planning and content review)
- GA4 or ad-platform webhook fires when a campaign’s CAC doubles overnight (minute-level response to pause or rebalance spend)
- Automatic comment wakes keep the agent responsive on existing campaign tasks
You get minute-level responsiveness on what matters without paying for 24 hourly wakeups you’d mostly spend on empty queues.
When to keep cadence tight anyway
A couple roles still benefit from a short base interval even with events wired up:
- Active approval loops. If the CEO is processing a heavy approval backlog, 2 to 4 hourly wakes let decisions land the same day.
- Live campaigns or launches. Pull the relevant agent tighter for 24 to 48 hours, then ratchet back once the launch is stable.
For everything else: default long, trust events for speed, and only shorten the polling loop when you have specific evidence that work is getting missed.
The baseline-override pattern
Step 1. Create an overrides directory
your-repo/
scripts/
apply-baseline-overrides.sh
docs/
baseline-overrides/
paperclip/
SKILL.md ← stripped version
para-memory-files/
SKILL.md ← stub or stripped
paperclip-create-plugin/
SKILL.md ← stubStep 2. Strip paperclip/SKILL.md
Copy the vanilla SKILL.md from ~/.npm/_npx/<hash>/node_modules/@paperclipai/server/skills/paperclip/SKILL.md into your overrides directory, then remove sections your agents don’t use.
Step 3. Stub para-memory-files (if you don’t use PARA)
If your project uses its own memory system (repo-based readouts, a wiki, Notion, whatever), replace the SKILL.md with a 10-line stub:
---
name: para-memory-files
description: >
PARA memory system. Not used by this company. See your role's bundle
for the memory model.
---
# PARA Memory Files: not used
This company does not use PARA, qmd, or $AGENT_HOME/life/.
See your external bundle for how memory works here.If you DO use PARA, leave it alone.
Step 4. Stub paperclip-create-plugin
Unless your agents build plugins at runtime (they almost certainly don’t):
---
name: paperclip-create-plugin
description: >
Plugin scaffolding. Not used at runtime.
---
# Create a Paperclip Plugin: not used at runtime
Plugin development is not a runtime agent task. Ignore this skill.Step 5. Leave paperclip-create-agent alone
The CEO genuinely needs this for hiring workflows. At 144 lines and about 1,600 tokens, the cost is acceptable given hiring is infrequent. You could stub it for pure IC agents, but the savings are small and the risk of breaking a hire flow is real.
Step 6. Write the apply script
#!/usr/bin/env bash
set -euo pipefail
REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
OVERRIDES="$REPO_ROOT/docs/baseline-overrides"
# Find the Paperclip npx install
for d in "$HOME"/.npm/_npx/*/node_modules/@paperclipai/server/skills; do
[ -d "$d" ] && SKILLS_DIR="$d" && break
done
[ -z "${SKILLS_DIR:-}" ] && echo "ERROR: Paperclip not found" >&2 && exit 1
echo "Target: $SKILLS_DIR"
for override in "$OVERRIDES"/*/SKILL.md; do
skill=$(basename "$(dirname "$override")")
target="$SKILLS_DIR/$skill/SKILL.md"
[ -f "$target" ] && cp "$override" "$target" && echo " applied: $skill"
done
echo "Done. Restart Paperclip to pick up changes."Run after every Paperclip install or upgrade:
./scripts/apply-baseline-overrides.shExpected savings
| What | Vanilla | Overridden | Saved |
|---|---|---|---|
paperclip/SKILL.md | 541 lines | ~350 lines | ~190 lines (~2,800 tokens) |
paperclip-create-plugin | 101 lines | 10 lines | ~91 lines (~900 tokens) |
para-memory-files | 104 lines | 10 lines | ~94 lines (~900 tokens) |
paperclip-create-agent | 144 lines | unchanged | 0 |
| Total per wake | 890 lines (~14,400 tokens) | ~514 lines (~10,000 tokens) | ~376 lines (~4,400 tokens) |
These are the IC-level savings (CMO, CRO, CTO). CEO retains paperclip-create-agent for hiring workflows and saves ~1,800 per wake; across a 5-agent org that averages to roughly 3,900 tokens per heartbeat, or about 30 percent of baseline overhead removed every time.
Role-specific optimization
CEO
The most complex role. It delegates, hires, approves, and coordinates. It legitimately uses more of the baseline than any other agent.
What the CEO actually needs from baseline skills:
| Skill | Verdict |
|---|---|
paperclip (core heartbeat, critical rules, comment style, planning) | Keep |
paperclip (issue dependencies, board approvals, execution-policy wakes) | Keep |
paperclip (project setup, company skills, import/export) | Keep. CEO uses these. |
paperclip (OpenClaw, self-test, searching issues) | Strip unless you use OpenClaw |
paperclip-create-agent | Keep. CEO hires. |
paperclip-create-plugin | Strip. Dev task, not CEO. |
para-memory-files | Keep if using PARA; strip if repo-based memory |
CEO external bundle tips:
- AGENTS.md should define delegation routing for your org, not the default CTO / CMO / UXDesigner. Replace the default routing table with your actual C-suite.
- HEARTBEAT.md should contain only supplements to the baseline procedure (your memory model, your readout conventions, your Asana / Jira / Linear conventions). Do not repeat the 9-step heartbeat. It’s already in the baseline.
- SOUL.md is already good out of the box. Add company-specific tone rules (for example, “don’t inflate numbers publicly”) and the principal relationship framing.
- MEMORY.md: if you use PARA, keep it short (seed entities and pointers). If you don’t, replace with a 10-line “our memory model” file. Do not copy the PARA explanation. It’s already in the baseline skill.
CEO override savings: about 1,800 tokens per wake (strip OpenClaw + self-test + create-plugin stub; more if not using PARA).
CMO (Chief Marketing Officer)
An execution-focused IC from Paperclip’s perspective. Doesn’t hire, manage projects, or configure company skills.
What the CMO actually needs:
| Skill | Verdict |
|---|---|
paperclip (core heartbeat, critical rules, comment style, planning, status guide) | Keep |
paperclip (issue dependencies, board approvals) | Keep |
paperclip (project setup, company skills, import/export, OpenClaw, self-test) | Strip |
paperclip-create-agent | Strip (CMO doesn’t hire) |
paperclip-create-plugin | Strip |
para-memory-files | Keep if using PARA; strip if not |
CMO external bundle tips:
- Define the CMO’s scope clearly: what campaigns, channels, and metrics they own vs what they hand off to CRO / CTO.
- Include a coordination protocol: how CMO requests instrumentation from CTO, how it feeds lead-quality data to CRO.
- Keep AGENTS.md under 80 lines. The CMO doesn’t need delegation routing in most setups.
- Skip HEARTBEAT.md supplements unless you have company-specific cadence rules.
CMO override savings: about 4,400 tokens per wake (full IC strip plus create-agent stub).
CRO (Chief Revenue Officer)
Pipeline-focused. Qualifies leads, manages sequences, tracks conversion, coordinates with sales humans.
Same baseline needs as CMO: core heartbeat, critical rules, comment style, planning, dependencies, approvals. Nothing manager-specific.
CRO external bundle tips:
- Define pipeline stages and qualification criteria in the external bundle. This is the CRO’s operating manual.
- Include CRM and pipeline tool conventions (what fields matter, what statuses mean).
- Coordinate explicitly with CMO (lead-quality feedback) and CTO (instrumentation requests).
- Lead-level wakes belong to sales ops, not the CRO. Route raw inbound to a Sales Ops or SDR agent via webhook trigger; escalate to the CRO only on rollup signals (forecast miss, large-deal stage change, weekly pipeline review). See “Event-triggered wakes beat polling” above.
CRO override savings: about 4,400 tokens per wake, same as CMO.
CTO (Chief Technology Officer)
The most technically complex IC. Writes code, reviews PRs, manages infrastructure, may hire engineering specialists.
What the CTO actually needs:
| Skill | Verdict |
|---|---|
paperclip (core heartbeat, critical rules, comment style, planning) | Keep |
paperclip (issue dependencies, board approvals, execution-policy wakes) | Keep |
paperclip (project setup) | Keep. CTO may set up project workspaces. |
paperclip (company skills, import/export, OpenClaw, self-test, routines) | Strip unless CTO manages skills |
paperclip-create-agent | Maybe keep. CTO may hire engineering ICs. |
paperclip-create-plugin | Strip (or keep if CTO builds plugins) |
para-memory-files | Keep if using PARA; strip if not |
CTO external bundle tips:
- The CTO’s AGENTS.md should define what “technical task” means for your stack: languages, frameworks, deployment targets, test expectations.
- Include a clear boundary with CMO and CRO: “You build what they request. You don’t decide what to build.”
- If the CTO hires engineering specialists, keep
paperclip-create-agent. If not, stub it.
CTO override savings: 2,800 to 4,400 tokens per wake depending on whether you keep project setup and create-agent.
Cost impact at scale
Assumptions: 4-agent C-suite plus CEO (5 agents total), running at Paperclip’s 1-hour default cadence (120 total wakes per day). Vanilla baseline averages ~19,700 input tokens per wake across roles; overridden averages ~15,800. Prices reflect Anthropic’s April 2026 API rates.
Sonnet 4.6 ($3 / MTok input)
| Scenario | Per-wake tokens | Wakes/day | Daily cost | Monthly |
|---|---|---|---|---|
| Vanilla (5 agents) | ~19,700 avg | 120 total | ~$7.09 | ~$213 |
| Overridden (5 agents) | ~15,800 avg | 120 total | ~$5.69 | ~$171 |
| Savings | ~$1.40/day | ~$42/mo |
Opus 4.6 ($5 / MTok input)
| Scenario | Per-wake tokens | Wakes/day | Daily cost | Monthly |
|---|---|---|---|---|
| Vanilla (5 agents) | ~19,700 avg | 120 total | ~$11.82 | ~$355 |
| Overridden (5 agents) | ~15,800 avg | 120 total | ~$9.48 | ~$284 |
| Savings | ~$2.34/day | ~$71/mo |
Opus 4.7 ($5 / MTok input, new tokenizer)
Opus 4.7 ships with a new tokenizer that can consume up to 35% more tokens for the same source text. The dollar-per-token rate is unchanged from Opus 4.6, but per-wake token counts scale accordingly, and so does the savings ceiling.
| Scenario | Per-wake tokens | Wakes/day | Daily cost | Monthly |
|---|---|---|---|---|
| Vanilla (5 agents) | ~26,600 avg | 120 total | ~$15.96 | ~$479 |
| Overridden (5 agents) | ~21,300 avg | 120 total | ~$12.78 | ~$383 |
| Savings | ~$3.18/day | ~$96/mo |
Stack the levers
These are the override-pattern savings at default cadence. Pair the override with a 6-hour heartbeat (20 wakes/day), and the all-in monthly bill drops dramatically:
| Model | Vanilla @ 1h default | Overridden @ 6h tuned | Combined savings |
|---|---|---|---|
| Sonnet 4.6 | ~$213/mo | ~$28/mo | ~$185/mo (87%) |
| Opus 4.6 | ~$355/mo | ~$47/mo | ~$308/mo (87%) |
| Opus 4.7 | ~$479/mo | ~$64/mo | ~$415/mo (87%) |
These are pure input-side savings on context injection. They don’t include the behavioral savings from agents spending fewer output tokens reasoning over irrelevant skill text.
Maintenance
When Paperclip upgrades
Every npx paperclipai run may pull a new version. New versions add genuinely useful features (scoped-wake fast path, issue dependencies, board approvals were all recent). After an upgrade:
- Check if the vanilla baseline changed:
diffyour override against the new installed version. - If new sections were added, decide whether to keep or strip them.
- Update your override, commit, and rerun the apply script.
- Restart Paperclip.
When to re-evaluate
- After hiring a new agent type (does it need skills you stripped?).
- After Paperclip ships a major feature (does the stripped content now matter?).
- Monthly: check how far your override has drifted from upstream. If too far, consider contributing upstream instead.
The upstream ask
The best long-term fix is for Paperclip to make baseline skills configurable:
- Split
paperclip/SKILL.mdintopaperclip-core(IC) andpaperclip-manager(CEO or board). - Make
paperclip-create-agent,paperclip-create-plugin, andpara-memory-filesopt-in viadesiredSkillsinstead ofrequired: true. - Add a company-level baseline config that lets operators choose which skills mount by default.
Until then, I hope this override approach helps save your organization both time and money.
+ Alex