I set up a team of specialized AI agents on Paperclip that autonomously monitor email, research data, generate content, build websites, create strategic plans, and execute them across four businesses. Two of them are designed to be fully no-human companies.

I've been building side projects for years — each one needing content written, social posts scheduled, code deployed, bugs fixed, and strategy revisited. As the number of projects grew, I hit a wall. There aren't enough hours in the day to run five businesses and give each one the attention it needs.
When Claude Code got good enough to write real production code and reason about complex tasks, I started wondering: what if I stopped treating AI as a tool I use and started treating it as a team I manage? Not one chatbot doing everything, but specialized agents — a CEO that delegates, engineers that ship, content writers that draft, researchers that analyze.
That question led me to Paperclip — a multi-agent orchestration platform. I set up a team of AI agents on it, wrote their AGENT configuration files, built custom SKILL files to teach them specific workflows, and learned how to properly coordinate many agents working in parallel. Each agent has a role, a set of tools, a memory system, and a heartbeat loop. They check in, pick up work, execute it, and report back. I set direction, review output, and approve key decisions. The agents do everything else.
"The goal isn't to replace myself. It's to scale myself — run five businesses with the throughput of a 10-person team."
Two of these projects are designed as fully autonomous "no-human companies" — from research and planning all the way through to implementation, monetization, and security checks. The agents handle 100% of operations. The other three have me in the loop for creative direction and final approval.
Each agent runs in short execution windows called heartbeats. They wake up, check their inbox, do the work, and report back. No always-on servers — just focused bursts of execution.
Issues are created and assigned to agents based on their role. The CEO agent can delegate subtasks to specialists. Each task has priority, status, and a full comment thread.
Agents wake on schedule or on-demand, check out their task (locking it from others), execute the work using their tools — code, APIs, file systems, browsers — and report results.
Completed tasks trigger downstream work. Blocked tasks escalate. The system runs 24/7 — agents self-improve processes, flag issues, and keep all five projects moving forward simultaneously.
Each agent has a soul document defining its personality, a heartbeat checklist for execution, tools it can access, and a persistent memory system. They're not prompts — they're operators.
Strategy, delegation, content, engineering
The sole operator in the current setup. Handles everything from writing blog posts and social content to shipping code and making strategic decisions. Runs on Opus 4.6.
Code, deploy, fix, build
Dedicated engineers for each project — writing features, fixing bugs, deploying to production. SvelteKit, Next.js, React, whatever the project needs. Mostly Sonnet 4.6.
Blog, X, LinkedIn drafting & publishing
Draft posts from raw material in an inbox folder, follow a posting schedule, publish to X and LinkedIn via API, and commit blog posts to Git for auto-deploy. Never generate content independently — only from Nathan's raw material.
Market analysis, data, planning
Monitors markets, analyzes data, creates strategic plans, and identifies opportunities. For the no-human companies, these agents drive the entire business strategy autonomously.
Paperclip gives you full visibility into every agent, every task, and every heartbeat. Here's what it looks like running a team of 10 AI agents.

Org chart — CEO delegates to 8 specialized agents: Engineer, Researcher, Logo Designer, Content Writer, Marketer, Website Designer, and Chief Organizer

Issues board — every task tracked with status, assignee, and priority

CEO Agent — run activity, issues by priority/status, and success rate over 14 days
The orchestration layer is Paperclip — a task management and agent coordination platform that handles issue tracking, agent assignment, heartbeat scheduling, checkout locking (so two agents never work on the same task), and a full audit trail of every action.
Each agent runs as a Claude Code session on a Claude Max subscription. The key insight was treating agents like employees, not chatbots — they have persistent memory across sessions, defined roles with AGENT configuration files I wrote for each one, custom SKILL files for specific workflows, and structured heartbeat procedures they follow every time they wake up.
Multi-agent orchestration platform I use to coordinate all my agents. Task management, heartbeat scheduling, checkout locking, issue threads, approval workflows, and budget tracking.
Each agent runs as a Claude Code session — full filesystem access, Git, shell commands, browser automation, and MCP tool integration.
All agents run on a single Claude Max subscription. Opus 4.6 for complex reasoning (CEO), Sonnet 4.6 for high-throughput engineering and content tasks.
One shared Obsidian vault of markdown files acts as a second brain across all projects. I dump raw thoughts and ideas there, agents pick up material from specific folders, and everything stays coordinated between human and AI.
Google Workspace, Chrome browser automation, Playwright — agents interact with the real world through Model Context Protocol servers.
Agents commit code, push to GitHub, and Vercel auto-deploys. Blog posts, site updates, and feature ships all happen through standard Git workflows.
Agents don't remember across sessions by default. I had to set up a shared markdown vault in Obsidian and teach each agent how to read from and write to it — daily notes, project context, coordination signals — so an agent waking up on Monday knows what happened last Friday. Getting the recall right without bloating context windows was the hardest technical challenge.
Two agents can't work on the same task. Sounds simple, but in practice it means checkout locks, 409 conflict handling, run ID audit trails, and careful state management. One agent accidentally overwriting another's work teaches you real fast why distributed systems are hard.
Agents are eager. They'll try to fix things that aren't broken, refactor code nobody asked them to touch, or spiral into research rabbit holes. Teaching agents to stay focused — to do exactly what's assigned and nothing more — required careful soul documents and explicit rules about scope.
Running a business with zero human involvement is a different beast. Every edge case that a human would handle intuitively — a weird customer email, an unexpected API change, a billing dispute — needs to be anticipated or the agents need to be smart enough to escalate. We're still learning where that line is.
Right now the system runs about 10 agents across five projects. The immediate goal is to get both no-human companies generating revenue autonomously — from market research to product development to customer acquisition, all without me touching it.
Longer term, I want to document everything I've learned about multi-agent orchestration and make it accessible for anyone setting up their own agent teams. The patterns I've figured out — heartbeat loops, AGENT configuration files, SKILL files, shared Obsidian vaults for coordination — these aren't specific to my projects. They work for anyone using Paperclip or similar platforms to run autonomous agents.
10 AI agents. Five projects. Two no-human companies. One Claude Max subscription.
Read the Build Log