Naïve removes Paperclip: Our v2 switch to Hermes

Naïve Studio v2 ships today with Hermes as its default agent runtime and orchestration framework. Paperclip, which v1 of Studio was built on, has been removed.

This is a substantive change to one layer of the stack. It is also, deliberately, not a change to what Naïve actually is.

What Studio v2 ships

Studio is the place a non-technical founder goes to spin up an autonomous company in chat — pick a template, talk to a CEO agent, watch employees do real work. Under the hood it has always been three layers:

1. Primitives — LLC formation, virtual cards, KYC, phone numbers, email infrastructure, domains, social posting, app deployment, research, images, and video. This is what Naïve actually builds.
2. Orchestration / runtime — the layer that decides which agent does what, when, and routes results between them. This is what Hermes (and previously Paperclip) provides.
3. Self-improvement — feedback loops, evaluation, templates, learned-behavior storage. Built by us, on top of whichever runtime is mounted underneath.

In v1, layer 2 was Paperclip. In v2, layer 2 is Hermes. Layers 1 and 3 are unchanged.

Why Hermes

The honest answer is that Hermes shipped a set of primitives this year that map almost exactly onto what an autonomous company actually needs:

• A durable, multi-agent kanban (docs) where every task is a row in SQLite, every handoff is a comment any profile can read, and every worker is a full process with its own identity. Handoffs survive restarts, context compression, and crashes.
• Named agent profiles with persistent memory. A sales, ops, or inbox-triage profile accumulates context over time instead of starting from zero on every spawn.
• Resumable tasks. Block → human comments → unblock → re-run. A worker that needs a decision halts cleanly and resumes from where it left off when an answer arrives.
• A built-in dispatcher with PID-level crash detection, timeout enforcement, claim TTLs, and a circuit breaker for tasks whose profile is misconfigured. We were going to write this.
• Human-in-the-loop is a first-class primitive, not an afterthought. Founders comment on tasks from a phone via Telegram, Discord, Slack, email, or SMS through the gateway, and the comment lands on the task thread the next worker reads.
• Structured audit trail. Every transition is an append-only event row. For an agent that's running a real business with real money, that's the difference between a postmortem you can run and one you can't.
• Subagent delegation, scheduled tasks (cron), code execution, event hooks, batch processing, worktrees for engineering tasks — all built in.

Most of these are things we would have had to build ourselves on top of Paperclip. Several are things we did build, in less mature forms, on top of Paperclip. Hermes does them better.

Side-by-side comparison

This is not a dunk. Paperclip is well-engineered, MIT-licensed, and was the right choice for v1. The frame here is: for the specific job of running a multi-agent autonomous company in 2026, which framework gives Studio a better foundation today?

For workloads that are one agent doing one task in one process, the gap is small. For the workload Naïve actually serves — N named employees collaborating on durable work that crosses days, restarts, and humans — the gap is large. So we switched.

We are grateful for the work Dotta and the Paperclip community put into v1. The primitives that Studio depends on did not go away because we changed the runtime; they exist because of the year we spent on top of Paperclip. That work is acknowledged in our Terms of Service §7.4 and our Open Source Licenses page, and that acknowledgement remains in place.

What Naïve actually is

Studio bundling a particular framework has, in some readings, been confused with Naïve being that framework. It is worth being explicit:

Naïve is a CLI and a primitives layer for any agent. Point Hermes at it, point Paperclip at it, point Claude Code or Codex or CrewAI or your own MCP-compatible runtime at it — they all get the same set of tools:

• Form an LLC.
• Issue virtual cards and enforce per-agent budgets.
• Provision a phone number and an email inbox on a custom domain.
• Pass KYC.
• Deploy apps, connect domains, publish on social, and route media/content workflows through documented primitives.
• Distribute on social channels.

None of that lives in any agent framework. None of it can. It is a separate layer — the layer that turns "an agent doing tasks" into "a company doing business" — and it is what we build.

The five-minute path from zero to a working agent making primitive calls is the quickstart:

npm install -g @usenaive-sdk/cli
naive register --name "My Agent" --email owner@example.com --password securepassword123
naive search "latest AI agent frameworks"

Or, if you'd rather hand the work to an agent directly:

I want you to follow https://api.usenaive.ai/skill.md and setup naive

Any agent that can read a skill manifest can register, authenticate, and start using primitives autonomously. That is the product. The framework Studio happens to ship under the hood is an implementation choice we expect to update again as the field moves.

On runtime choice, going forward

Studio will continue to ship whichever orchestration framework is the current state of the art for multi-agent collaboration on autonomous companies. Today that is Hermes. Yesterday it was Paperclip. Tomorrow it may be something else, and if it is, we'll switch again and write a similar post.

The CLI does not change when the runtime changes. The primitives do not change when the runtime changes. Companies running on Naïve do not change when the runtime changes. That is the entire reason we drew the line where we did.

We are not in the business of building the best agent orchestrator — that category is moving fast and is being done well by people who are focused on it. We are in the business of being the place those orchestrators come to when their agents need to incorporate, bank, hire, ship, and get paid.

Questions? Reach us at dennis@usenaive.ai.