Spinup vs Factory
Factory's primitive is the Droid Computer: a persistent machine purpose-built for Factory's own Droids. Spinup is a harness-neutral agent runtime above the machine: one durable agent, one computer, any harness, with workspace-owned identity, skills, secrets, lifecycle, and a recorded history of every run. Both reject ephemeral sandboxes. The fork is whether the runtime is tied to one agent product or works across all of them.
Common Ground
A shared bet on persistence
Both products are reacting to the same market failure: ephemeral sandboxes are not enough for serious agent work.
Persistence as a design principle
Factory argues that persistence is the new paradigm for cloud agents. Spinup is built on the same premise. Both treat state, filesystem continuity, and environment longevity as first-class properties, not afterthoughts.
Asynchronous, long-running workflows
Both support asynchronous, background agent workflows where agents run while users are offline and return to the same context they left. Neither is optimized for one-shot request-response execution.
Key Differences
Open runtime vs closed ecosystem
The fork is whether the runtime is tied to one agent system or works across all of them. Persistence is table stakes for both.
Ecosystem openness
Droid Computers are built for Factory's Droids. The environment model, skill accumulation, and orchestration layer are designed around that specific agent product. Spinup is harness-neutral: OpenClaw and Hermes are the supported harnesses today, with Claude Code, Codex CLI, and others on the roadmap. The agent owns its identity and configuration regardless of which harness runs.
Portable skills and secrets
Spinup binds skills and secrets to the agent, not to the harness or machine. Swap the harness and the agent's configuration travels with it. Factory's Droids accumulate skills and session context within the Factory ecosystem. That knowledge does not transfer if you move to a different harness.
Machine model
Factory's BYOM option lets users register their own machines as Droid Computers at no cost. Spinup takes a cloud-native path: agents run in isolated environments managed by the runtime, always consistent and always separated from other tenants.
Workspace controls
Spinup provides workspace-level controls: membership, audit logging, and secrets managed across a team's agent fleet. Factory's Droid Computers support remote orchestration across machines but the governance model is scoped to the Droid ecosystem.
Side-by-Side
Spinup vs Factory at a glance
| Spinup | Factory / Droid Computers | |
|---|---|---|
| Primary abstraction | The agent: a persistent environment with skills, secrets, and a swappable harness | The Droid Computer: a persistent machine for orchestrating Droids |
| Harness support | OpenClaw and Hermes today; Claude Code, Codex CLI, and others on the roadmap | Factory's Droids specifically |
| Persistence model | Agent-scoped state, intact across harness changes and environment rebuilds | Filesystem, configuration, credentials, and process memory across sessions |
| Machine ownership | Cloud-native isolated environments per agent, managed by the runtime | Factory-managed cloud computers or BYOM (register your own machine) |
| BYOM | Cloud-managed only | Free for all users |
| Skills and learning | Skills bound to the agent and portable across harnesses | Droids accumulate skills from sessions within the Factory ecosystem |
| Workspace controls | Membership, audit logging, workspace-scoped secrets management | Remote orchestration across machines within the Droid ecosystem |
| Best fit | Teams running agents across harnesses who want portable runtime controls | Teams using Factory's Droids who want managed persistent machines |
The Ecosystem Question
Vertically integrated vs open runtime
Factory is right about persistence. Their "persistence is the new paradigm" framing names a real shift in how production agents need to be operated, and Droid Computers are a serious product built on that conviction. If your team uses Droids and wants an environment model designed for them, Factory has built exactly that.
The tradeoff is vertical integration. Droid Computers, Droids, session skills, and remote orchestration are all part of a single coherent system. That coherence is a strength: things fit together cleanly. It is also a constraint. The skills Droids accumulate, the orchestration model, and the machine semantics are built around Factory's specific agent product. Teams running OpenClaw or Hermes today, or waiting on Claude Code or Codex CLI to land on Spinup, are outside the intended scope.
Spinup answers the same persistence conviction with a different architecture. The runtime is harness-neutral: the canonical agent object carries its skills, secrets, and configuration when you swap the harness. A team running OpenClaw today and switching to Hermes tomorrow does not rebuild the agent's setup. Claude Code, Codex CLI, and other harnesses on the roadmap will land on the same shape. The agent is the durable object. The active machine is replaceable capacity. The runtime holds the continuity.
Both approaches take persistence seriously. The choice is whether you want a vertically integrated system optimized for one agent product, or an open runtime that works across all of them.
When to Choose
Closed ecosystem or open runtime
Neither product is universally better. The right choice depends on which harnesses your team uses and how much portability you need.
Choose Spinup when
You run agents across multiple harnesses, or plan to evaluate and compare them. Your team wants to swap harnesses without rebuilding the agent's setup each time.
Choose Spinup when
You need workspace-level controls (secrets scoping, audit logging, membership policy) that govern agents across a team rather than per-machine configuration.
Choose Factory when
Your team is using Factory's Droids and wants the environment model purpose-built for them. The BYOM option is attractive, or you want Droids to accumulate skills and session context inside a managed system.
Choose Factory when
You are comfortable with vertical integration and do not need to switch or compare harnesses. Factory's coherent stack moves fast when everything runs inside the same ecosystem.
FAQ
Spinup vs Factory questions
What is the main difference between Spinup and Factory's Droid Computers?+
Factory's Droid Computers are persistent machines built specifically for Factory's Droids, their own agent system. The environment, skills, and orchestration model are designed for that ecosystem. Spinup is harness-neutral: OpenClaw and Hermes are supported today, and Claude Code, Codex CLI, and others are on the roadmap. The agent owns its identity, skills, and secrets regardless of which harness is running.
Is Spinup a Droid Computers alternative?+
If you are using Droids specifically, Droid Computers are the natural home: they are purpose-built for that ecosystem. If you want to run agents across different harnesses, compare them, or avoid tying your runtime to one vendor's agent product, Spinup is the alternative. The comparison only holds where the workloads overlap: persistent, long-running agent execution.
What is BYOM and does Spinup offer something similar?+
Factory's BYOM (Bring Your Own Machine) option lets users register laptops, workstations, or VMs as Droid Computers. Spinup takes a different approach: agents run in isolated cloud environments managed by the runtime, rather than on machines you register. Spinup does not have a BYOM model today. The tradeoff is that Spinup environments are always isolated, consistent, and runtime-managed.
When should I choose Factory over Spinup?+
When you are using Factory's Droids as your agent system and want the environment model Factory built for them. Droid Computers provide persistence, BYOM flexibility, and session continuity that fits naturally inside the Factory ecosystem. If your team is committed to Droids and does not need to switch or compare harnesses, Factory's vertically integrated stack can move faster than assembling a separate runtime layer.
Related
Understand the runtime layer
These pages explain how Spinup approaches persistent agent environments and why being able to swap harnesses without rebuilding matters.
Early access
Run agents across harnesses without rebuilding the environment.
Request access if this is the runtime shape your team has been missing.