Factory pricing: what do I get on the $20/month plan, and when does Max make sense?

If you’re deciding between Factory’s Pro plan at $20/month and the higher-capacity Max tier, the real question is: how much agent workload do you want to delegate, and how many engineers will be running Droids in parallel?

This breakdown walks through exactly what you get on the $20/month plan, what “Factory Standard Tokens” actually mean in practice, and when it’s worth stepping up to Max.

---

Quick Answer: The best overall choice for most individuals and small teams starting with Factory is Pro ($20/month). If your priority is running Droids heavily across a small team and avoiding token friction, Max ($200/month) is often a stronger fit. For larger organizations, complex codebases, and custom limits, consider Enterprise.

At-a-Glance Comparison

Rank	Option	Best For	Primary Strength	Watch Out For
1	Pro ($20/mo)	Individual devs & very small teams validating Droids in real workflows	Complete coding agent workspace with frontier models at low cost	Limited shared token pool; best for focused, daily use rather than org-wide automation
2	Max ($200/mo)	Small teams running Droids heavily across IDE, web, and CLI	100M Standard Tokens + 100M bonus, better fit for continuous usage and scripted automation	5-seat cap before add-on seats; you still need to manage usage patterns
3	Enterprise (Custom)	Larger orgs, complex repos, strict governance needs	Unlimited members, advanced repo permissions, enterprise-scale analysis	Requires sales conversation; overkill if you’re just testing Factory with a couple of engineers

Comparison Criteria

We evaluated each plan against how real teams actually use Droids:

• Capacity & scalability: How many tokens and seats you get, and how well the plan supports continuous agent usage (long sessions, parallel CLI runs, multi-developer teams).
• Surfaces & integrations: Where Droids can operate (desktop, web, CLI, background agents) and how well they plug into your existing SDLC and collaboration stack.
• Enterprise readiness: Controls and collaboration features that matter once Droids move from “trying it out” to “part of the team’s workflow.”

---

Detailed Breakdown

1. Pro — $20/month (Best overall for individuals and early team trials)

Pro ranks as the top choice because it gives you the full agent-native experience—frontier models, multi-surface Droids, and background agents—at a low commit, which is ideal for proving out real workflows before scaling.

You get:

• Dedicated compute with frontier models
  Access to state-of-the-art models (e.g., GPT-class, Claude-class, Gemini-class; full list in the product) through Factory’s model-agnostic runtime. The emphasis is on agent design, not a single model vendor—so you keep a consistent workflow even as models evolve.

• Token capacity tuned for daily use

  • 10M Factory Standard Tokens per month, shared across all models.
  • +10M bonus tokens on top.
    Practically, this is enough to:
  • Run Droids in your IDE for code generation, refactors, and tests on a daily basis.
  • Have multi-hour sessions where a Droid traverses your repo, proposes edits, and explains context.
  • Trigger Droids from the browser for docs, design notes, and quick incident investigations.

• Agent-native, multi-platform experience
  Pro includes the full “Droids everywhere you work” setup:

  • Desktop / web / CLI: Droids in VS Code/JetBrains/Vim-style environments, browser, and terminal.
  • Cloud & local background agents: Let Droids run tasks that aren’t tied to a single interactive session—e.g., longer investigations or multi-step refactors.
  • Expanded first-party integrations: Hooks into your source, project tracker, and collaboration tools so Droids can pull context from tickets, repos, and chat without you manually pasting it.

• Team collaboration for up to 2 members

  • Up to 2 team members, with $5 per additional seat.
  • Shared analytics, billing, and usage stats.
  • Agent-readiness dashboard to see where Droids can have the most impact (e.g., which repos or workflows are good candidates).

This makes Pro a good fit if you want to:

• Run Droids in your editor and terminal as a daily assistant.
• Delegate end-to-end tasks (refactors, lightweight incident triage, migrations on limited scope) without retooling your SDLC.
• Keep costs predictable while you measure impact in concrete artifacts (files changed, PRs opened, tests added).

What it does well:

• Low-friction entry with real Droids, not just autocomplete
  You’re not buying a toy copilot. Pro lets you:

  • Ask a Droid to plan a refactor, modify multiple files, and prepare a PR.
  • Run incident diagnostics from Slack/CLI and get structured findings.
  • Generate tests and docs tied to the same context the Droid used to modify code.

• Covers all key surfaces from day one
  Because Pro includes desktop, web, and CLI access plus background agents, you can:

  • Use the web UI for exploration and onboarding.
  • Shift to the IDE/terminal once you’re ready to let Droids touch your actual dev workflows.
  • Start experimenting with scripted Droids in CI/CD using the CLI, even if you keep scopes small initially.

Tradeoffs & limitations:

• Token pool fit for depth, not massive scale
  10M Standard Tokens (+10M bonus) is ample for:
  • 1–2 engineers using Droids heavily day-to-day, or
  • A small team doing focused experiments.
    It’s not ideal if you want:
  • Many engineers hammering Droids concurrently all day, or
  • Large-scale scripted migrations across dozens of repos via CLI.

Decision Trigger: Choose Pro if you want to validate Factory in real workflows—with frontier models, full surfaces, and background agents—without overcommitting. It’s the right call when you care about agent depth per engineer more than organization-wide throughput.

---

2. Max — $200/month (Best for small teams with heavy, continuous Droid usage)

Max is the strongest fit when your main constraint isn’t features—it’s capacity. You’ve already proven that Droids create value; now you want to run them more often, across more people, and in more automated flows without hitting token ceilings.

You get everything in Pro, plus:

• Expanded reserved capacity

  • 100M Factory Standard Tokens per month, shared across models.

  • +100M bonus tokens.
    This is a 10x jump in base tokens compared to Pro, plus matching bonus capacity. It’s designed for:

  • Multi-engineer teams running Droids heavily in IDEs.

  • Frequent CLI-driven automation (code review, bulk edits, smoke tests).

  • Long-running “Droids in the war room” during incidents and high-traffic periods.

• Early access to new features
  You get earlier exposure to:

  • New planning strategies and toolchains (e.g., improved environment discovery, better repo analysis tools).
  • Fresh integrations and workflow surfaces.
    For teams building processes around Droids (CI flows, runbooks, playbooks), early access means you can shape how those features land in your environment.

• More collaboration headroom

  • 5-seat cap by default, with $5 per additional seat.
    Compared to Pro’s 2-seat base, Max is tuned for small teams who want a shared agent infrastructure, not just a couple of power users.

What it does well:

• Supports continuous, high-throughput agent workflows
  100M+100M tokens unlock patterns like:

  • Automated review at scale: Droids reviewing most PRs for style, safety checks, and test coverage suggestions.
  • Recurring maintenance tasks: Scripted Droids in the CLI handling dependency updates, API shim insertions, or cross-repo consistency checks.
  • Deeper incident playbooks: Droids that can follow multi-step runbooks, hitting logs, code, and tickets without you watching every token.

• Smooths over token anxiety for serious teams
  When Droids move from “nice-to-have” to “part of how we ship,” token second-guessing kills adoption. Max gives you room to:

  • Let engineers use Droids whenever they reach for them, without micro-managing prompts.
  • Experiment with more aggressive automation (e.g., parallel Droids per service in CI/CD) while you tune patterns using Factory Analytics.

Tradeoffs & limitations:

• Still a capped, team-scale plan
  Max is deliberately scoped for small to mid-sized teams. Limitations:
  • 5-seat cap before you add more seats; if you’re heading towards org-wide rollout, you’ll quickly start thinking in Enterprise terms.
  • Token capacity is large but not infinite—massive monorepo migrations or org-wide automation might still be constrained.

Decision Trigger: Choose Max if you already know Droids are valuable and you want high-throughput, multi-engineer usage across IDE, web, Slack/Teams, and CLI—especially if you’re starting to script Droids in CI/CD or treat them as part of your incident response playbooks.

---

3. Enterprise — Custom (Best for large organizations and complex environments)

Enterprise stands out when your priority is not just more tokens, but organization-wide deployment with robust controls over access, governance, and analytics.

You get everything in Max, plus:

• Enterprise scale

  • Unlimited team members: Roll Droids out across multiple teams, orgs, and business units.
  • Custom messaging and token limits: Align capacity with distinct groups (e.g., platform team vs. product squads).
  • Advanced repository permissions: Refine which Droids can see what, mapping to your existing repo and role structures.

• Enterprise features

  • Enterprise-scale codebase analysis: Let Droids analyze and operate on large, complex repositories without manual chunking or ad-hoc context hacks.
  • Configurations and controls aligned with:
    • Strict permissions enforcement (Droids only see what users can see).
    • Audit logging you can export to your SIEM.
    • Single-tenant, sandboxed environments with dedicated VPC options.
    • Alignment with SOC 2, GDPR/CCPA, and early adoption of ISO 42001.
    • Clear IP stance: Factory does not use your code as training data without prior written consent.

This is where Droids become part of organization-wide processes: automated reviews across all services, standardized incident playbooks, and CI/CD tasks that parallelize work across dozens or hundreds of repos.

What it does well:

• Centralized governance with distributed usage
  Enterprise gives you a way to:

  • Delegate work to Droids everywhere (IDE, browser, CLI, Slack/Teams, backlog).
  • Keep security and compliance teams satisfied with visibility and control over where data flows.
  • Measure ROI not through token counts, but through Factory Analytics (files edited, commits, PRs, autonomy ratio) and OpenTelemetry export.

• Fits complex, regulated environments
  Ideal if you:

  • Operate in regulated industries.
  • Need full traceability from ticket to code to incident.
  • Have strict boundaries around which codebases and environments a given engineer—or Droid—may touch.

Tradeoffs & limitations:

• Overkill for small teams
  If you’re just testing Factory with a couple of developers, Enterprise is more machinery than you need. It shines when you’re standardizing Droids across many teams and want deep governance and reporting.

Decision Trigger: Choose Enterprise if you’re rolling Droids out across multiple teams or departments, need unlimited seats and advanced permissions, and care about SIEM-integrated auditability and compliance as much as throughput.

---

Final Verdict

Use the $20/month Pro plan when you want to:

• Prove that agent-native development fits your workflows.
• Let 1–2 engineers run Droids across IDE, web, and CLI with enough tokens for serious daily use.
• Keep spend low while you tie results to real outputs: PRs, commits, reduced MTTR, faster refactors.

Move to Max when:

• Multiple engineers are using Droids daily and resenting token ceilings.
• You’re starting to script Droids in CI/CD or for recurring maintenance.
• You want tokens to stop being the bottleneck while you design real processes around Droids.

Step up to Enterprise when:

• You’re ready for an org-wide rollout.
• You need unlimited seats, advanced repo permissions, and enterprise-scale analysis.
• Security, compliance, and leadership want verifiable controls and measurable outcomes, not just another dev tool line item.

If you’re unsure where your usage will land, Pro is the safest starting point: you get the full Droid experience, then you can upgrade to Max once you see sustained workloads and clear ROI in your own metrics.

Next Step

Get Started