# Costs

Starwisp is a one-time purchase with 12 months of updates (see [updates](updates.md)). **You pay every vendor directly** for what your runs use. This page shows what to expect.

> **One run has been measured; the rest are estimates.** The Anthropic figures below come from one paid clean-room Prototype (November 2026, all stages on Claude Opus 5.5 through an API key) and a model of how the Prototype preset's lighter settings change it. Vendor prices change; check each vendor's page.

## The headline

- **Almost all of the cost is Anthropic (Claude).** Expect about **$135 to $225 in Claude for a Prototype** (typical about $170, estimated) and about **$265 to $310 for Ship to testers**, plus the small vendor lines below.
- **What was measured:** a Prototype on the settings Ship to testers still uses cost **about $290 in Claude** before Launch: Vision $9, Design $87, Build $180 (a $45 first attempt, then $135 for a second attempt that started over), Security $4, Experience Review $4 plus $6 of a fix round. Verify passed with no agent cost. (That run's page showed $286: the $4 review was not counted there yet.) The run stopped at an Anthropic spend limit before Launch and Retro.
- **Since then the Prototype preset is lighter** (in the release after Starwisp 0.1.3): smaller Design and Build crews, Sonnet for their helper agents, lean prompts. The Verify gates and the Experience bar are unchanged. The Prototype figures are an estimate from the measured run until a Prototype is measured on the new settings.
- After launch, a prototype costs about $0 to $2 a month; a first shipped app about $30 to $55 a month (estimate).

## Per build, variable

### Claude, per stage

| Stage | Measured (old settings) | Prototype now (estimate) | Ship to testers (estimate) |
|---|---|---|---|
| Vision | $8.87 | about $8 | about $9 |
| Design | $87.18 | about $35 to $45 | about $87 |
| Backend | $0.46 (the app had no backend) | $0.50, or about $5 to $12 with a backend (not measured) | same as Prototype |
| Build | $134.93 for a complete pass (plus a $45.16 first attempt it redid) | about $65 to $85 | about $135 |
| Security | $3.59 | about $3.50 | about $3.60 |
| Verify | $0 (passed in round 1) | $0 to $20 (a fix round, if needed; not measured) | $0 to $20 |
| Experience Review | $4.38 review + $5.50 of a fix round (stopped) | about $20 to $40 (reviews plus up to two fix rounds; not measured) | same |
| Launch, Retro | not reached | about $4 to $11 (not measured) | about $5 to $13 |
| Ship | not in Prototype | none | little or no Claude (a scripted stage) |
| **Total** | **about $290** before Launch | **about $135 to $225, typical about $170** | **about $265 to $310** |

Where the money went in the measured run: output tokens 42%, cache writes 33%, cache reads 24%. Design launched 27 helper agents and Build 37; each read a large part of the app (100,000 to 350,000 tokens of context), and reviewers plus one fresh fix agent per finding were about a third of Design. The Prototype now runs one brand direction instead of three, two reviewers instead of three, one fix agent per area, three Build reviewers instead of six, and its Design and Build helpers on Sonnet 5.5, which costs half as much as Opus 5.5 per token. The stage leads, Vision, Backend, Security, the Verify and Experience fixers and the Experience reviewer stay on Opus.

The estimates could be off by a third either way. Sonnet helpers could need an extra Verify fix round; that is inside the ranges above.

### Everything else

| Line | Prototype | Ship to testers |
|---|---|---|
| Idea Studio (chat and review) | $1 to $5 | $1 to $5 |
| GitHub Actions beyond your free allowance | $0 to $4 | $0 to $4 |
| Expo builds | $0 (no store build) | $2 to $19 |
| Supabase | $0 to $10 | $0 to $10 |
| Resend, Cloudflare | $0 to $5 | $0 to $5 |
| Twilio (only if SMS) | n/a | about $26 |
| **Total per app, Claude included** | **about $135 to $250** | **about $270 to $380** |

## Fixed costs (not per app)

| Item | Cost | When |
|---|---|---|
| Domain (optional for both presets; needed for app email and email sign-in for outside testers) | about $10 to $15 | per year |
| Apple Developer Program (Ship to testers) | $99 | per year |
| Google Play Console (Ship to testers) | $25 | once |
| Supabase Pro | $25 base | per month, once you need more than 2 projects or hit free limits |
| Expo Starter (optional) | $19 plus usage | per month |
| Twilio 10DLC (only for SMS) | about $4.50 + $15 once; about $2/month | |

A prototype has no fixed cost: without a domain it goes live free on `workers.dev` (a domain is about $12 a year if you want one). Shipping one app to both stores with Supabase Pro costs about $424 in the first year before Anthropic ($436 with a domain).

## Monthly cost per live app (small scale, estimate)

| | Prototype | Ship to testers / stores |
|---|---|---|
| Total, first app | about $0 to $2 | about $30 to $55 |
| Each extra app | $0 until the second Supabase project is paid for | +$10 to $30 |

## Set limits before your first run

The agents can spend real money, and a stuck run keeps spending. Set **both** of these.

### 1. Anthropic spend limit (the hard backstop)

1. Open <https://platform.claude.com/settings/spend-limits> (Claude Console → Settings → Spend limits).
2. Set a **monthly spend limit** that you could afford to lose. For a first month, a figure at or just above your single-app high estimate (about $400) is reasonable; one measured run on the old settings cost about $290 before Launch.
3. If your console offers workspaces, put Starwisp in its own workspace and set the limit there.

Starwisp does not control this limit. It is the one that always works, even if something in Starwisp is wrong.

When a run hits it, the stage stops with "Anthropic spend limit: …", the date access returns, and what to raise. Starwisp never resumes such a run by itself, because that would spend next month's money without asking: raise the limit (or wait for the date) and press **Resume**.

### 2. Starwisp budget caps (Settings → Budget)

| Cap | What it does |
|---|---|
There are two kinds of cap. The **Claude caps** cover the agents that build the app (almost all of the cost). The **backend caps** cover paid vendor steps only and **do not include Claude**.

| Cap | What it does |
|---|---|
| **Claude per-run cap** (new installs: $400) | The most one run may spend on Claude. A stage that reaches it **pauses**: raise the Claude cap in Settings → Budget, then **Resume**. `$0` or blank means no cap. |
| **Claude monthly cap** (new installs: $800) | The most Claude may cost in a calendar month across all runs. New runs wait once it is reached. |
| **Monthly backend cap** (default $300) | The most paid *vendor* actions (Supabase projects, Expo builds, app AI usage, SMS) may cost in a month. Not Claude. At `$0` every paid backend step stops. |
| **Per-app backend cap** (default $120) | The most paid vendor actions for one app. Not Claude. It cannot be higher than the monthly backend cap. |

New installs start with a Claude per-run cap of **$400** and a monthly cap of **$800**: the measured run ($290 on the old settings) and a Ship to testers run (about $265 to $310) fit under the per-run cap with room for a retry; a Prototype (about $170) leaves more. An install made before these defaults has **no Claude cap** until you set one; Settings → Budget warns and offers those values with one click. Raise a cap when a stage pauses and you are happy with the progress.

How the caps work:

- Dollars are booked after each stage, one ledger line per Claude attempt: the tokens each model used (input, cache writes, cache reads, output) times the factory's dated price table. Claude Code's own figure is kept next to it as a cross-check. The run page shows the spend so far.
- A resumed run counts each attempt once. A resume that reports its whole session's running total is reduced to its own share, and recording the same attempt twice adds nothing.
- Starwisp supports API keys only: set `ANTHROPIC_API_KEY` in the Vault. (If a subscription token is also there, the token is used and the dollars are notional.)
- On a subscription token the run page labels the figure "notional"; on an API key it says "billed to your API key". The ledger records which kind of credential each attempt used, never the credential itself.
- The vendor caps use **flat estimates** booked before spend, not invoices. They gate Supabase projects, Expo builds, app AI keys and SMS. They do not include Anthropic or GitHub Actions minutes.

## What is not included

- GitHub Actions minutes beyond your plan's free allowance (macOS minutes cost more).
- App runtime AI (your app calling Claude or OpenAI for its users): estimated $0 to $26 a month at about 2,000 calls, depending on the model; the factory books a flat $5 a month.
- Updates to a live app by running the factory again: a fraction of a build, an estimate of $10 to $60.