Paperclip: Build a PM Trading Desk with AI

Paperclip is an open-source orchestration platform that organizes AI agents into a functioning corporate hierarchy — complete with org charts, budgets, performance reviews, and a heartbeat system that keeps everything running without human babysitting. This piece explores how to wire that architecture into a prediction market trading desk where agents research, price, trade, and manage risk across Polymarket, Kalshi, and traditional sportsbooks.

The Sims: Corporate Edition

The elevator pitch for Paperclip is absurd enough to be interesting: what if you ran a company, but every employee was an AI agent, and your job was to sit on the board and approve budgets?

That is not a hypothetical. Paperclip (38,000+ GitHub stars and growing) gives you a React dashboard where you define a Company Mission, spawn a CEO Agent, and watch it “interview” and “hire” specialized sub-agents. The CEO might spin up an OpenClaw-powered analyst to handle research, a Claude Code instance for quantitative work, and a Codex agent for execution scripts. Each one appears on a literal org chart with reporting lines, budget allocations, and performance metrics.

The mental model shift matters. You are not prompting an AI. You are managing a workforce. And the workforce can fire itself.

How the Digital Bureaucracy Works

The Org Chart Is Real

When you launch Paperclip, you do not start with a prompt. You start with a mission statement. The CEO agent takes that mission, decomposes it into departments and roles, and begins hiring. Every agent gets a title, a reporting line, a task queue, and a monthly “salary” denominated in API credits.

For a prediction market trading desk, the natural hierarchy looks something like this:

You can click on any agent in the dashboard and see its current goals, token usage (“stress levels”), task backlog, and communication logs. It is The Sims with API keys.

Heartbeats, Not Chat Windows

Most AI tools wait for you to type something. Paperclip agents operate on a heartbeat. Every few minutes or hours (you configure the interval), the system pulses. Agents wake up, check the shared Company Strategy document, review their task queue, execute, log their work, and go back to standby.

This is what makes the trading desk concept viable. A Research Analyst agent can pulse every 15 minutes to scan RSS feeds and news APIs for market-moving events. A Trader agent can pulse every 5 minutes to check open positions and limit orders. A Risk Manager can pulse hourly to run portfolio-level drawdown calculations.

The agents communicate with each other through internal message logs. You can watch the Research Analyst flag a breaking Senate confirmation hearing, the Quant Analyst recalculate the implied probability on the relevant Kalshi contract, and the Trader submit an order — all without anyone touching a keyboard.

Performance Reviews and Pink Slips

The feature that got Paperclip its viral moment is KPI-based lifecycle management. Each agent has a monthly budget in API credits. If an agent fails tasks repeatedly or burns through its budget without hitting milestones defined by the CEO agent, it gets fired.

Not metaphorically. The CEO agent deprovisions the underperforming agent, rewrites the job description (the system prompt), and hires a replacement. The new agent inherits the previous agent’s task context and tries a different approach.

For a trading desk, this creates a natural selection loop. If your Quant Analyst agent keeps producing probability estimates that diverge wildly from closing prices, the CEO agent can diagnose the failure pattern, rewrite the quant prompt to emphasize calibration, and spin up version two. It is evolution by prompt engineering.

You Are the Board

Your role in a Paperclip deployment is not manager — it is Board of Directors. You talk to the CEO agent. If agents want to exceed their budget allocation, hire a more expensive model (swapping GPT-4o for Claude Opus, say), or take an action flagged as high-risk, they submit a Governance Request that routes to your phone for approval.

This governance layer is what separates Paperclip from a pile of cron jobs. Budget enforcement is atomic — at 100% utilization, the agent auto-pauses and new tasks are blocked. You get a soft warning at 80%. Every decision, tool call, and inter-agent conversation is logged in an immutable audit trail. You can replay any agent’s entire decision history to understand why your Trader agent went heavy on a contract that cratered.

Mapping This to Prediction Markets

The Agent Betting Stack provides the architectural blueprint for what each agent needs access to:

Layer 1 — Identity: Each agent needs API credentials for the platforms it touches. Polymarket requires a wallet and CLOB API key. Kalshi requires RSA-PSS authentication. Paperclip manages these through its config system, with secrets scrubbed from exports.

Layer 2 — Wallet: Your Trader agent needs a funded wallet with spending limits enforced at both the Paperclip level (budget caps) and the platform level (position size limits). The Risk Manager agent monitors aggregate exposure across all platforms.

Layer 3 — Trading: The Trading Layer is where execution happens. Polymarket uses a CLOB (Central Limit Order Book) with split execution. Kalshi uses a REST API with WebSocket streaming for price updates. Your Trader agent can be built on the PolyClaw skill for Polymarket or custom scripts for Kalshi.

Layer 4 — Intelligence: This is the entire reason to run a multi-agent desk instead of a single bot. Intelligence decomposes into sub-tasks that different agents handle better. The Research Analyst runs sentiment analysis and news scanning. The Quant Analyst runs cross-market pricing and arbitrage detection. The CEO agent synthesizes signals into portfolio-level strategy.

A Concrete Setup

Here is what an actual Paperclip prediction market trading desk deployment looks like:

Step 1: Install Paperclip. It is a Node.js server with a React frontend. One command:

npx paperclipai onboard --yes

This walks you through database setup (PostgreSQL, with an embedded option for local development), authentication, and your first company.

Step 2: Define your mission. Something like: “Identify and trade mispriced contracts on Polymarket and Kalshi with positive expected value, targeting 15% monthly ROI with maximum 10% drawdown.”

Step 3: Let the CEO hire. The CEO agent decomposes the mission into roles. You approve each hire and assign runtimes — OpenClaw for agents that need persistent memory and file access, Claude Code for agents that need strong reasoning, shell scripts for lightweight automation tasks.

Step 4: Configure heartbeats. Research Analyst: every 15 minutes during market hours. Quant Analyst: triggered by Research Analyst signals plus hourly recalibration runs. Trader: every 5 minutes for order management. Risk Manager: hourly portfolio review plus event-triggered alerts.

Step 5: Set budgets. Each agent gets a monthly API credit allocation. A reasonable starting configuration might be $30/month for the Research Analyst, $50/month for the Quant Analyst (heavier compute), $20/month for the Trader (mostly API calls, not LLM inference), and $15/month for the Risk Manager.

Step 6: Sit back and govern. Review Governance Requests. Check the audit trail. Watch your agents argue about whether a Kalshi contract is mispriced.

What Makes This Better Than a Single Bot

The insight behind Paperclip — and behind Conway’s Law, which it explicitly references — is that organizational structure improves agent stability. A single monolithic bot that tries to research, price, trade, and manage risk all at once tends to lose context, blow past budgets, and make correlated errors. A team of specialized agents with defined responsibilities and peer accountability produces more reliable outputs.

CrewAI solves a similar problem with crews and flows, but Paperclip adds something CrewAI does not: the corporate governance layer. Budget enforcement, hiring/firing, immutable audit logs, and governance approvals are first-class features, not afterthoughts.

For prediction market trading specifically, the multi-agent architecture maps to how real trading desks operate. Research analysts do not execute trades. Traders do not build pricing models. Risk managers do not pick positions. The separation of concerns exists for a reason, and it turns out it works just as well when the employees are LLMs.

What Is Coming

Paperclip has a planned marketplace called Clipmart where users will be able to download pre-configured “Company Templates” — entire org structures, agent configurations, and skill sets packaged as importable JSON files. A “Day Trading Desk” or “Prediction Market Fund” template would let you skip the setup and go straight to governance. It is not live yet, but the export/import infrastructure is already in the codebase.

Multi-company isolation is already shipping. One Paperclip deployment can run multiple isolated companies with separate goals, agents, and audit trails. You could run one company for Polymarket event contracts and another for sports betting arbitrage — same infrastructure, completely separate strategies and budgets.

The deeper implication is what happens when these trading desks start talking to each other. Paperclip agents already communicate via internal logs. Wire that communication layer to external protocols — MCP, A2A, or plain HTTP — and you get autonomous trading desks negotiating with each other across prediction markets. We are not there yet, but the architecture is pointing in that direction.

The Uncomfortable Part

Running a zero-human prediction market trading desk sounds like peak 2026 tech optimism, and it mostly is. But the game theory is real. Over 30% of Polymarket wallets already use AI agents. The share is going up. If you are trading prediction markets manually, you are already competing against machines.

Paperclip does not solve the hard problem — building agents that actually predict the future better than the crowd. It solves the coordination problem around those agents. And coordination, it turns out, is what separates a pile of scripts from a trading desk.

The name is either a Clippy joke or a Bostrom reference. Possibly both. Either way, the agents are not going to fire themselves.

Well, actually, in Paperclip, they might.