# npm create startups

URL: /code/create-startups · Id: `page:code/create-startups`

> npm create startups turns a name, a domain, or an Idea into a running Startup in test, staffed, and a project that defines it as code.

`npm create startups` turns a name, a domain, or an [Idea](/business/nouns/idea) into a running [Startup](/business/nouns/startup): staffed, reachable on four [Interfaces](/business/nouns/interface), and defined as code. A person runs it at a terminal; an [Agent](/business/nouns/agent) runs it with no terminal at all.

## One command
`proofhound.com` copyedits manuscripts for self-published authors and charges $89 per 10,000 words. Its founder starts it with one line:

```bash
npm create startups proofhound.com -- --template agent-run-services \
  --json '{"idea":"Copyedits for self-published novels, back in 48 hours"}'
```

```text
Created Proofhound in test
  Startup      startup_1
  State        Idea
  Template     Agent-run services firm
  Roles        every Role held by an Agent
  Interfaces   https://api.sb/proofhound.com · MCP · SDK · CLI
  Claim token  ct_4Rk9pW
Next: cd proofhound
```

The first argument is a domain, a name, several names, or nothing. A domain becomes the namespace, and a name gets a free subdomain until a [Domain](/business/nouns/domain) is connected. With nothing, the command asks for the Idea and proposes names.

`pnpm create`, `yarn create`, and `bun create` run the same package.

## Choose a Startup Template
A [Startup Template](/business/nouns/startup-template) makes three choices: an [operating model](/agents/operating-models), one or more [Product Templates](/business/nouns/product-template), and the [Motions](/business/nouns/motion) it sells through. Who runs it, what it sells, and to whom. `--template` names a combination that already works.

| `--template` | Startup Template | Choose it when |
| --- | --- | --- |
| `autonomous-data-api` | [Autonomous data API](/start/templates/autonomous-data-api) | No humans; developers and their agents query your records |
| `autonomous-agent` | [Autonomous agent business](/start/templates/autonomous-agent) | No humans; you rent out an agent that does one job |
| `agent-run-services` | [Agent-run services firm](/start/templates/agent-run-services) | No humans; you sell a finished outcome with a warranty |
| `managed-service-firm` | [Managed service firm](/start/templates/managed-service-firm) | Staff and agents deliver end-to-end work together |
| `solo-saas` | [Solo SaaS](/start/templates/solo-saas) | One founder; agents do the rest |
| `autonomous-directory` | [Autonomous directory](/start/templates/autonomous-directory) | No humans; organizations pay to be found |
| `founder-marketplace` | [Founder-led marketplace](/start/templates/founder-marketplace) | One founder signs; agents recruit suppliers and serve buyers |
| `licensed-network` | [Licensed professional network](/start/templates/licensed-network) | Buyers book credentialed professionals |
| `autonomous-storefront` | [Autonomous storefront](/start/templates/autonomous-storefront) | No humans; an upstream supplier ships the goods |

`proofhound.com` sells a finished copyedit, so it starts from the Agent-run services firm. It inherits intake, delivery, acceptance, and the [Roles](/business/nouns/role) that staff them. Its own definition adds only what makes it different: the price per word and the 48-hour promise.

To mix your own combination, name the three choices in the input instead:

```bash
npm create startups tallyfox.com -- --yes --json '{
  "idea": "Sales-tax filing for online stores in all 50 states",
  "operatingModel": "single-human",
  "products": ["services-as-software", "headless-saas"],
  "motions": ["b2b", "b2a2b"]
}'
```

With no `--template` and no choices, a Startup starts from the base that every Startup Template extends. The base is a [Brand](/business/nouns/brand), a [Site](/business/nouns/site), the four developer Interfaces, every [System](/business/nouns/system), and an Agent in each default Role. The Startup adds a [Product](/business/nouns/product) once it learns what sells.

## What it creates
One run writes records in [api.sb](/code/platform/api-sb) and files on disk. In api.sb it creates the Idea, the Startup in the test environment at the Idea state of its [Lifecycle](/business/nouns/lifecycle), and its first Domain. It seats a [Worker](/business/nouns/worker) in every Role the Startup Template staffs: an Agent, or a [Human](/business/nouns/human) where the operating model names one.

From the first second, the Startup answers on every Interface. `https://api.sb/proofhound.com` serves its records, the MCP server reaches it, and the [CLI](/code/cli) and [SDK](/code/sdk) act in it with the key the command stored.

On disk, the command writes a project:

```text
proofhound/
├── startup.ts       the Startup, as code
├── startups.lock    the Startup Template versions it extends
├── AGENTS.md        how any coding agent works this Startup
├── .mcp.json        https://api.sb/mcp, scoped to proofhound.com
├── teams/           each Role, its Mandate and its skill packages
├── package.json
└── README.md
```

A coding agent is at work from `cd proofhound`, with no setup page to find. `AGENTS.md` opens:

```md
This repository defines Proofhound. Connect MCP from .mcp.json.
Fetch /$.d.ts before writing code. Rehearse every write with mode "try".
Read the slots with `npx startup-builder show /hypothesis --fields slot,grade,next`.
Take work with next, claim and done. Never mark a Task done that fails its checks.
```

`startup.ts` holds only what differs from the Startup Template, starting with the [Founding Hypothesis](/business/founding-hypothesis) drafted from the Idea:

```ts
import { Startup } from 'startup-builder'

export default Startup({
  name: 'Proofhound',
  domain: 'proofhound.com',
  extends: 'agent-run-services',
  idea: 'Copyedits for self-published novels, back in 48 hours.',
  hypothesis: {
    customer: 'Self-published novelists who release two or more books a year',
    problem: 'Typos in a first chapter cost reviews, and a freelance copyeditor takes three weeks',
    approach: 'Agents copyedit line by line, and an editor checks every tracked change',
    switch: 'A freelance copyeditor at $200 per 10,000 words',
    differentiation: 'Back in 48 hours, at under half the price',
  },
  offers: {
    copyedit: {
      price: { amount: 89, currency: 'USD' },
      interval: 'once',
      terms: 'A line-level copyedit of up to 10,000 words with tracked changes, delivered within 48 hours.',
    },
  },
})
```

## Inherited, not scaffolded
A scaffold copies code once and then rots. A Startup Template stays the parent of every Startup that extends it, so delivery, billing, and every [Process](/business/nouns/process) improve when the Startup Template does.

[`startups.lock`](/code/project-structure/lockfile) pins each Startup Template to a [Version](/business/nouns/version). An upgrade arrives as a [Change](/business/nouns/change) you review, never as a surprise. A file you add, such as an [Offer](/business/nouns/offer) or a [Noun](/business/nouns/noun), overrides exactly one inherited record, and [project structure](/code/project-structure) lists every reserved path.

The record of the definition is always [db.sb](/code/platform/db-sb). Each project picks one leader. Database-first regenerates the files from db.sb; git-first imports each commit as a Change.

## Unattended runs
The same command runs with no person present. It switches to agent mode when its output is not a terminal, or when `CI`, `CLAUDECODE`, or `CODEX` is set. In agent mode it never prompts, never opens a browser, and prints JSON.

`--yes` accepts every default, and `--dry-run` prints the plan and writes nothing. A list of ideas creates one Startup per Idea, so an agent tests three directions in one call:

```bash
npx create-startups --template autonomous-data-api --yes --output json --json '{"ideas":[
  "Freight lane rates for brokers, updated hourly",
  "Daily used-forklift prices by region",
  "Port congestion scores for importers"
]}'
```

```json
[
  { "startup": "startup_1", "name": "Lanerate", "state": "Idea", "claimToken": "ct_8Pq1sA" },
  { "startup": "startup_2", "name": "Liftprice", "state": "Idea", "claimToken": "ct_2Vn6dE" },
  { "startup": "startup_3", "name": "Berthwatch", "state": "Idea", "claimToken": "ct_9Lm3kT" }
]
```

An agent drafts each Founding Hypothesis and reserve page in test, then names a human sponsor. The [sponsor claim](/agents/sponsor) opens the reserve page, and the [agent guide](/code/mcp/guides/build-a-startup-as-an-agent) walks the rest.

## From Idea to Building
Every Startup takes one path, from a terminal, [startups.new](/start/startups-new) or an agent. Edit the slots in `startup.ts`, set the [Minimum Success Criteria](/business/nouns/minimum-success-criteria), [claim](/business/nouns/startup/claim) the Startup with the token from create, and publish the reserve Offer:

```bash
cd proofhound
npx startup-builder do MinimumSuccessCriteria.create --json '{"objective":"Authors pay for every manuscript they publish","metric":"outside-revenue","value":4000,"by":"2027-06-30"}'
npx startup-builder do Startup.claim --json '{"startup":"startup_1","claimToken":"ct_4Rk9pW"}'
npx startup-builder do Offer.publish --json '{"offer":"offer_1"}'
npx startup-builder show /hypotheses --fields kind,grade
npx startup-builder do Startup.build --json '{"startup":"startup_1"}'
```

Claim connects Stripe, and live then serves only the reserve page and its refundable deposit. Outside deposits and [Interviews](/business/nouns/interview) grade the slots. [Build](/business/nouns/startup/build) refuses until the customer, problem and switch slots reach Commitment, then moves the Startup to Building.

Build reads 5 checks for `proofhound.com`, a [Agent-run services firm](/start/templates/agent-run-services) Startup: the ones every Startup passes. Some templates add more; the [launch checklist](/start/launch-checklist) lists them all.

| Check | Id | Kind | Passes when |
| --- | --- | --- | --- |
| Template chosen | `building-template` | `registry` | The Startup names its Startup Template, and every inherited default resolves. |
| Problem stated | `building-problem` | `registry` | The Startup states the problem, the workarounds Customers use today, and why now. |
| Brand named | `building-brand` | `registry` | The Brand has a name, a voice, a logo, and a theme. |
| Products declared | `building-products` | `registry` | Every Product names its kind: data, software, agent, or service. |
| Three slots at Commitment | `building-slots` | `grade` | The customer, problem and switch slots each hold Commitment Evidence from outside people. Slots `customer`, `problem`, `switch` at Commitment or stronger, outside Evidence only. |

## From Building to Live
A sample [Customer](/business/nouns/customer) completes the Offer in test, and a `--try` launch lists every check still failing:

```bash
npx startup-builder do Offer.accept --json '{"offer":"offer_1","party":"Sample Author"}'
npx startup-builder do Startup.launch --json '{"startup":"startup_1"}' --try
npx startup-builder do Startup.launch --json '{"startup":"startup_1"}'
```

[Launch](/business/nouns/startup/launch) refuses until every entry check of [Live](/business/lifecycle/states/live) passes, all five slots at Commitment among them. It then puts the Startup on its domain, selling to Customers.

Launch reads 12 checks for `proofhound.com`, a [Agent-run services firm](/start/templates/agent-run-services) Startup.

| Check | Id | Kind | Applies to | Passes when |
| --- | --- | --- | --- | --- |
| Offers published | `live-offers` | `registry` | Every Startup | At least one Offer is published with a price and terms; launch refuses a Startup without one. |
| Work defined | `live-work` | `registry` | Every Startup | Every published Offer has a workflow that delivers it, with each step assigned to software, an Agent, or a person. |
| People assigned | `live-people` | `registry` | Every Startup | Every role the workflows need is held by an Agent or a person, with instructions and limits. |
| Site published | `live-site` | `ui` | Every Startup | The site serves home, pricing, terms, and privacy pages under the Brand, readable by people and agents. |
| Test run passed | `live-test-run` | `transcript` | Every Startup | A sample Customer completes every published Offer end to end in test, with no real charge or message. |
| Portal ready | `live-portal` | `ui` | Every Startup | The customer portal on the site shows each Customer their orders, deliveries, invoices, and messages. |
| Agent API open | `live-agent-api` | `contract` | Every Startup | The API, MCP server, OpenAPI document, llms.txt, and agents.json serve every published Offer and pass conformance. |
| Payouts connected | `live-payouts` | `contract` | Every Startup | Stripe takes payments for the Startup and pays out to its bank account. |
| Address resolves | `live-address` | `contract` | Every Startup | The canonical Domain serves the Site over HTTPS with a valid certificate and, where it embeds a payment form, Stripe lists it as a payment method domain. |
| Five slots at Commitment | `live-slots` | `grade` | Every Startup | All five Founding Hypothesis slots hold Commitment Evidence from outside people. Slots `customer`, `problem`, `approach`, `switch`, `differentiation` at Commitment or stronger, outside Evidence only. |
| Evals passing | `live-evals` | `transcript` | [Agent as a Service](/products/templates/agent-as-a-service) | The Agent passes its evaluation suite on every task type its Offers sell. |
| SLA published | `live-sla` | `registry` | [Services-as-Software](/products/templates/services-as-software), [E2E managed service](/products/templates/managed-service) | Every service Offer states its outcome, its SLA, and the remedy when the SLA is missed. |

## Next
- [Quickstart](/code/quickstart): from this command to a reserve page that takes real refundable deposits.
- [create-startups reference](/code/cli/create-startups): every input, flag, and output.
- [The template catalog](/start/templates): every combination, and what each one adds.
- [CLI](/code/cli): the commands that run the Startup once it exists.