---
title: "Personal plans"
description: "Four plans for one person (Free, Pro, Max 5x and Max 20x): a dev setup provisioned in one step, three meters you can see at any moment (agent usage in a 5-hour and a weekly window, compute and storage), every Frazer product on every paid plan, more running at once and priority at peak on the higher plans, your own model plans and keys at no Frazer fee, and Not run: no funds when money runs out."
url: https://frazer.ai/docs/billing/personal-plans
index: https://frazer.ai/docs/llms.txt
tokens: 2889
---

> For agents: this page is indexed at https://frazer.ai/docs/llms.txt, and every page at https://frazer.ai/llms.txt. Copy commands from this file exactly.

# Personal plans

Frazer has four plans for one person: **Free**, **Pro** at $20 a month ($200 a year), **Max 5x** at $100 a month and **Max 20x** at $200 a month. A paid plan provisions your whole dev setup in one reviewed step, and every Frazer product is on every paid plan: the higher plans buy more agent usage, more compute, more running at once and priority at peak. A plan covers your personal organization; teams use organizations, which pay usage and never seats.

> **The short version:** Three meters, visible at any moment: **agent usage** (any model at its list price, in a 5-hour and a weekly window), **compute** (vCPU-hours) and **storage**. Max 5x and Max 20x multiply Pro’s agent windows by 5 and 20. Bring your own model plan or key at no Frazer fee. When money runs out, work does not run and says so on the item, with one action; it never runs a cheaper way, and reading, exporting and saving your work never stop.

## The plans

|  | Free | Pro | Max 5x | Max 20x |
| --- | --- | --- | --- | --- |
| Price | $0 | $20 a month, or $200 a year | $100 a month | $200 a month |
| Agent usage | A starter window on the low-cost route: $0.08 per 5 hours and $0.25 a week | $0.30 per 5 hours and $1.25 a week, at list prices | 5 times Pro’s windows | 20 times Pro’s windows |
| Compute (boxes, cloud agents, databases, apps, CI beyond the free minutes) | — | 180 vCPU-hours a month | 900 vCPU-hours | 1,260 vCPU-hours |
| Private storage | 2 GiB | 100 GiB | 500 GiB | 1 TiB |
| Frazer CI | 200 minutes a month | The free minutes, then the compute pool | Same | Same |
| Cloud sessions at once | — | 2 · 10 with credits or your own key | 10 · 40 | 60 · 100 |
| Previews awake at once | — | 2 | 10 | 30 |
| Browsers at once | — | 2 | 10 | 40 |
| Campaigns at once | — | 1 | 3 | 10 |
| Priority at peak | Lowest | Standard | Higher | Highest, with opt-in early access |
| Support | Community | 2 business days | 1 business day | 1 business day, first in the queue |

Max is monthly only. What runs at once is a default, never a wall: with credits on, you raise each number up to its fair-use maximum, and work beyond that belongs to an organization. A session draws compute only while it runs and suspends while it waits, so the pool, not the count, is the real bound. Priority is an order of admission at peak: it never preempts running work and never changes the model or its speed.

Max carries no monthly Frazer credit; model work beyond the windows is paid by credits you turn on, or by your own model plans and keys at no Frazer fee (below).

**Pro for students** costs $10 a month with half of Pro’s usage, verified at purchase and every year. Maintainers in Frazer’s open-source program get Pro at no charge for 12 months at a time, by published criteria.

## What paying provisions

One **setup plan**, applied in about two minutes (a target), with everything you need to build with agents: a dev box from a template, the Frazer app linked, the `coder` and `reviewer` agents, the low-cost model route as the default, connections for your own model plan, Fir and Frazer CI, a database, an app on Frazer Serverless, a domain on Max, a hard spend cap at the plan’s price, and MCP for your own agents. A box sleeps after 5 idle minutes with its memory saved and wakes in about a second, drawing compute only while awake.

## Every product, on every paid plan

Every product draws the agent windows, the compute pool or storage, so a plan carries all of them without going negative:

| Product | On a paid plan |
| --- | --- |
| [Fir sessions](https://frazer.ai/docs/sessions) | Every session kept in full in the plan’s storage |
| [Harnesses](https://frazer.ai/docs/agents/harnesses) and the Lab | Every harness for every use; Try, Compare and Simulate sized by plan, each saying the difference it can detect before it starts |
| [Loops](https://frazer.ai/docs/source/planning-flow/loops) on agents’ plans and code | On by default for agent-authored work |
| [Frazer Reviewer](https://frazer.ai/docs/reviewer/lanes) | Every lane’s static stage, and model lanes at any depth from the window, with no per-review fee; depth set by risk, never cut to fit |
| Frazer Decisions | No fee on the personal organization; tokens from the window |
| [Frazer QA](https://frazer.ai/docs/previews/tests) (previews and test runs), [Frazer Browsers](https://frazer.ai/docs/agents/browsers) | From the compute pool, with the counts at once above |
| [Squads and campaigns](https://frazer.ai/docs/squads/campaigns), cloud sessions | From the compute pool and the window, with the counts at once above |
| [Installed agents](https://frazer.ai/docs/agents#install-agents-from-the-marketplace-with-budgets) | No count limit; each draws a default allocation of 20 % of each window and of the pool |
| [Skills](https://frazer.ai/docs/agents/skills) | The public index, your own skill repositories synced, private skills in your storage |
| The improvement step | Up to 10 % of each agent’s own draw, or skipped with the reason when that cannot decide anything |
| [Issues](https://frazer.ai/docs/source/issues): the monitoring and fix agents on your apps | Judgment and fix sessions from the window |
| Releases, the merge queue, programs, plans, person tasks, the CLI | Yes |
| Hub profile and achievements | The same for everyone, on every plan, with no plan badge |

**What a week holds** (estimates, one product alone using the whole window or pool): on Pro, a few agent layers reviewed with a loop and frontier critics, or about forty on Frazer’s own models where they are as accurate, or about 83 browser-hours; Max 5x about five times that; Max 20x about ten reviewed layers a day, or hundreds on Frazer’s own models. A week holds more through your own plans and keys, never by reviewing less. The usage page shows this week’s draw by product, by agent and session and by day, which source paid each line, the cost per merged and kept pull request, every item that did not run, and the forecast (“at this pace the weekly window ends Saturday 11:00”). You may cap a product’s share of each window; shares are off by default, because the default is the best way.

## Your own model plans and keys

| What you bring | How it works |
| --- | --- |
| A model provider’s subscription | Its own coding agent, unmodified, signs in through the provider’s own flow on your box; Frazer never collects, stores or relays that sign-in, and never resells or routes its usage |
| A sign-in with your provider, where the provider offers one to partner apps | The Frazer harness and the Frazer app draw your plan’s limits under your provider’s own controls |
| Monthly API or cloud credits that come with a plan | Connected once as a key; Frazer Reviewer, loops, Frazer Decisions, test runs, the Lab and Frazer harness sessions run on them at no Frazer fee |
| A provider API key | Stored in your secret store and used through the gateway, with no Frazer fee |
| Another harness | Runs on your box like any program |

You choose, per product, which source pays first (“Reviewer and loops: my API credits, then my Frazer window”), and every receipt names what paid. The Frazer app’s meter shows your Frazer windows beside your own plan’s windows, as your agent reports them on your box.

## At a limit: Not run: no funds

-   **Reserve before start.** Every model stage, review, loop, decision, test run, Lab run, campaign task and preview create or wake holds its estimate against every balance on its path (the windows, the pool, credits if on, a share or an agent’s allocation). If a hold fails, the work does not start; an admitted turn always finishes.
-   **The estimate first.** Every run that costs money carries an estimate before it starts: the p50 and p90 in dollars, its basis (the price list’s version, the models, the cache assumption, the depth), what pays for it and when the estimate expires. The hold is the p50, and the receipt names the model actually served.
-   **Pause between steps, keep the best.** A loop or task whose next step cannot extend its hold is “Paused: no funds”: the step in progress finishes and the session checkpoints (the receipt shows a `wrap-up` line), it keeps its best version, and it says what finishing needs.
-   **Said on the item:** “Not run: no funds” on the check row, the loop turn, the task card, the preview or the decision, with the reason, the shortfall, the reset (“needs $0.42 · $0.00 left in this week’s window · resets Fri 09:14”), what waits, and one action: **Use my key or plan**, **Top up**, **Wait**, or **Run tonight** where it applies. A lighter run happens only as your explicit choice, labeled “lighter than default by choice”.
-   **What never stops:** free deterministic checks; reading and exporting your repositories, sessions, records, reviews, usage and invoices; **Save work to a branch**; read APIs and MCP read tools; apps inside their reserve.
-   **For agents:** when time fixes it (a window), HTTP 429 with the `quota-exceeded` problem and CLI exit `6`; when money fixes it (credits, an allocation, the cap), HTTP 402 with the `https://frazer.ai/problems/no-funds` problem and CLI exit `13`. Both carry the reason, the balance, the amount needed, the reset, what waits, `next` and `retry`, so an agent’s retry loop never spins on an empty balance. The no-funds problem is documented with a JSON Schema and a contract version; its `reason` is a closed list that grows only by addition, and a reason a client does not know means “needs a person”, so a new reason never makes an agent retry.
-   **Top-ups:** only you pay. Credits start at $5, or auto-reload with a monthly ceiling; an agent prepares a top-up as a person task you approve with a passkey, one per account and shortfall. When funds arrive or a window resets, everything that did not run resumes on its own within 60 seconds.
-   **The cap** is the plan’s price, on by default; with credits on, the credit balance and your monthly ceiling.

## Promises

Allowances are contractual and the same for every account on a tier: no experiment ever changes what a paying person gets. Any reduction needs 30 days’ notice in the changelog and by email and never touches a paid term. The usage page and its export always carry dollars and tokens per call, session and product. Meters are visible everywhere, billing errors are refunded automatically, and there are no promotional resets. Upgrades apply at once and downgrades at the period’s end; **Cancel** is one step from the plan card; **Pause** for up to 3 months a year; a first-week refund; and your work stays readable and exportable after any plan ends.

```sh
frazer billing plans compare
frazer billing usage get --by product --json
frazer billing waiting list --reason no-funds
frazer billing credits buy 5 --dry-run
frazer status --statusline
```

> **For agents:** Read the windows from the `RateLimit` headers or `frazer billing usage get --json`. On a 429 or exit `6`, wait for the reset; on a 402 or exit `13`, stop and follow `next`: a top-up is a person task, never yours to pay. Never switch to a cheaper model to fit a window.

## Related

-   [Billing and budgets](https://frazer.ai/docs/billing): organizations, budgets, caps and invoices
-   [Sessions](https://frazer.ai/docs/sessions): what a plan’s storage keeps
-   [The CLI for agents](https://frazer.ai/docs/for-agents/cli): exit codes `6` and `13`

## Pages in Billing and budgets

- [Overview](https://frazer.ai/docs/billing.md)
- [Personal plans](https://frazer.ai/docs/billing/personal-plans.md) (this page)