Changelog.

What changed

The hierarchy had two levels and three names. The codebase-level container was a Product, the blueprint inside it was a Project, and the same blueprint was also called a Scope in URLs, buttons, and pricing. Those are now:

• Project — the thing you're building: one codebase, with its GitHub repo, project-wide Context, and memory. This was "Product".
• Scope — one planned piece of work inside a project: a blueprint of modules, features, and tasks. This was "Project".

A project holds as many scopes as it needs, and each scope inherits the project's repo and Context unless it overrides them. That was always how it worked; only the words moved.

Where you'll see it

• The header switcher reads Project / Scope. "New project" creates the container; "New scope" creates a blueprint inside it.
• Project settings live at /project/<id>/settings; the Project board is /scopes?project=<id>. The old /product/... routes are gone, so update any bookmarks.
• Pricing says 1 project on the free entry and unlimited projects & scopes on paid plans, and the plan comparison, FAQ, and docs match.
• Settings pages, the dashboard, usage, and cloud runs say "scope" wherever they used to say "project" for a blueprint.

For agents

MCP tool names are a public contract — installed skills and configured agents call them by name — so list_projects, get_project, create_project, and project_id are unchanged and still operate on a scope. The parent project is product_id. Every tool description and the session playbook now say so, and list_projects labels the parent list Projects, so an agent told to "add this to the Billing project" lands in the right place. A clean rename of the tool names will come with a versioned MCP release and a deprecation window, not a silent swap.

Nothing in your data or API keys changed.

The plans

• Builder — $49/mo ($490/yr). Unlimited projects and scopes, 1,000 credits a month, one concurrent cloud run, full MCP, Project Memory, run budgets and approval gates, BYOK.
• Pro — $99/mo ($990/yr). Everything in Builder, with 5,000 credits a month and 3 concurrent cloud runs.
• Team — $49/seat/mo ($490/seat/yr), two seat minimum. The price on the card is the total. Each seat adds a run slot and 1,000 credits to a shared pool.
• More — bigger teams, custom run capacity, custom billing, and a live onboarding walkthrough.

Extra concurrent run slots are $25/mo each. Credit packs stay $10 for 500, $20 for 1,500, and $50 for 5,000.

Free is unchanged: one project, 150 credits to start, full MCP, no cloud runs.

The plans

• Builder — $30/mo ($300/yr). Unlimited products and scopes, 1,000 credits a month, full MCP read/write, Project Memory and the Autopilot skill, one concurrent cloud run, run budgets and approval gates, BYOK with no credit limits.
• Team — $50/seat/mo ($500/seat/yr). Everything in Builder for every seat, one concurrent cloud run per seat, pooled credits, roles and permissions, real-time collaboration with field locking, multiple GitHub accounts.
• More — bigger teams, custom run capacity, custom billing, and a live onboarding walkthrough. Talk to us.

Extra concurrent run slots are $20/mo each on any plan, and credit packs are $10 for 500, $20 for 1,500, and $50 for 5,000.

What this means if you already subscribe

Nothing changes. The price you signed up at is the price you keep. This is the launch list price for new accounts, and it will move up over time as the product does, so getting in early is the deal.

The pricing page

The pricing page now carries a full plan comparison, line by line across Builder, Team, and More, and the FAQ covers credits, cloud run costs, unattended runs, BYOK, and what counts as a product.

Run budgets for the cloud queue

Leave a queue running without watching it. Set a budget from the run lane or straight from Architect Chat ("run the auth module, stop at $10"):

• Caps — max tasks, max cost in USD, max minutes. The queue stops on its own when any cap is hit.
• Gates — auto keeps going until a cap; per_task pauses after every run until you approve the next one.
• Pause on failure — a failed run pauses the queue instead of burning the rest of the budget on the next task.
• Run a whole module — pick a module, and every unstarted, agent-ready task is queued in dependency order under the budget you set.

Cost and time are read from the runs themselves, so the numbers in the lane are the numbers on your bill.

Autopilot skill

npx -y @scope-architect/mcp install-skill now installs three skills: the task workflow, model and cost guidance, and autopilot. Tell Claude Code, Cursor, or Codex to "run the module" and it pulls the next ready task, implements it, verifies the acceptance criteria, marks it done, and repeats. The scope is the only loop state, so a context reset resumes where it left off.

Onboarding ends at the first write-back

Three choices, then your first scope: which agent you use, where it works (your editor over MCP, or the cloud with a pull request back), and the project. The workspace then shows the matching connect step until your agent's first status update lands.

Also

• Settings → MCP creates your key on first visit; the snippets are copy-ready.
• Scope enrichment now runs on a stronger model, for deeper task specs and acceptance criteria.

One conversation, the whole loop

Architect Chat grew from a scope editor into the place you run the project from:

• Codebase-aware — with GitHub connected, Architect reads your real code while you talk: it browses the tree, searches, and cites the file paths it used, so scope changes are grounded in what actually exists.
• Queue and launch cloud runs — ask for it and Architect drafts a run plan: tasks queued in dependency order, the first run ready to start. Approve the card and Claude Code builds it in a fresh VM and opens a PR. Nothing executes without your approval.
• Run-aware — Architect sees active runs and the queue, so "what's running right now?" gets a real answer mid-conversation. A live run rail beside the chat shows running now, up next, and recently done.
• @-mention anything — pull any module, feature, or task into the conversation with full detail. Every drawer also has its own per-item Architect chat.
• Conversations that keep up — named, searchable, persistent threads with the full history, so long-running projects don't lose their reasoning.

Scope edits still arrive as diffable change plans you preview and apply in one click — that hasn't changed. What's new is everything around them.

Also shipped

• Live Preview for Cloud Runs — start a preview server on the run's VM and watch the agent's output in a live browser pane inside the Command Center, without waiting for the PR.
• Model catalog — a continuously synced catalog behind the model picker, plus the public model pricing comparison and agent stack directory on this site.
• BYOK model refresh — the latest Anthropic, OpenAI, Google, xAI, and DeepSeek models available with your own keys.

Cloud Sandboxes → Cloud Runs

Same isolated VMs, clearer name. Dispatch a scoped task, the agent builds it in a fresh cloud VM, and you get a pull request back. Grok joins Claude Code as a supported cloud agent, or run on your team's own API keys — always on your account, with no markup.

Launch pricing

• Free — $0, 1 product, 150 credits/mo, full MCP read/write. No card required.
• Builder — $49/mo ($490/yr): unlimited products, 1,000 credits/mo, BYOK, 1 concurrent cloud run.
• Team — $79/seat/mo ($790/seat/yr): pooled credits, a concurrent run per seat, real-time collaboration and role permissions.
• Extra concurrent cloud runs are +$19/mo each; one-time credit packs from $9.

The run queue

• Queue tasks in dependency order — the queue knows what depends on what and advances automatically as runs land.
• Dispatch confirm sheet — every queue-and-run action goes through one confirmation showing the real insertion order, with per-task agent and model choice before anything starts.
• Honest preflight — the run picker only offers agents that are actually connected and operational, and failures tell you why.

Product-level knowledge

Projects now live under a product, and knowledge lives with the product: the linked repo, context, and memories are inherited by every project in it — with clear badges showing where each piece came from.

Hosted MCP

The MCP server now runs hosted. Point Claude Code, Cursor, VS Code, Windsurf, Codex, or Gemini CLI at the endpoint, authorize with OAuth, and your agent is on the live plan — no npx install, no local process to keep alive. The stdio package (@scope-architect/mcp) still works if you prefer running it yourself, and both expose the same tool surface.

Connect GitHub + import your codebase

• GitHub App integration — link a repo and default branch to any project.
• Codebase import — Scope Architect walks the repo, summarizes it into Context, and detects your tech stack, so generated scopes extend your real code instead of scaffolding from zero. Brownfield projects are first-class now.

Also shipped

• Dependency system end to end — the engine generates dependencies, get_next_ready_task respects them, and the workspace surfaces them as chips and badges.
• Enrich scope — deepen any existing module or feature without regenerating the project.
• Two-stage generation pipeline — outline first, then parallel per-module task expansion, for larger and more consistent scopes.

Cloud Sandboxes (beta)

Every paid plan now includes dedicated VM sandboxes. Assign a scoped task, the agent runs it inside the sandbox, and you get a pull request back. Pause a sandbox to free the slot for another project.

• Connect Claude Code or Codex to run tasks in the cloud, no local setup required.
• Live tracking in the Command Center: statuses, comments, and flags update as the run progresses.
• GitHub integration: link a repo to the project and the sandbox opens its pull request against it.

Also shipped

• Token Analytics: per-operation token usage and spend across every project, in one usage dashboard.
• Preset Library: reusable module and feature presets that drop straight into a scope, so common builds start most of the way done.
• Export anywhere: clean JSON or Markdown export of any scope, ready to hand to any tool or agent.

A major repositioning. Scope Architect is now the missing planning layer between your idea and the AI agents that ship your code.

What's new

• Agent Handoff exports — generate a clean JSON or Markdown spec tuned for the LLM context window of Cursor, Claude Code, Devin, or Windsurf. Copy to clipboard, paste into your agent, watch it ship without follow-up clarifying questions.
• Builder Profile (replaces Studio DNA) — calibrate the engine to your tech stack, target agent, code style, and estimate unit. Same recursive engine, your defaults.
• Architect Chat as a first-class feature — refine your scope by talking to AI. Diffable change plans you preview and apply in one click.
• Dual views — Builder + Agent Handoff — full engineering surface for you, clean self-contained spec for your agent. Same source of truth, two perfect contexts.
• All AI agents supported — Cursor, Claude Code, Devin, Windsurf, plus a generic format for anything else.

What's gone

• eSign, invoicing, Stripe payment flows, polished client-facing proposal PDFs — all retired with the agency positioning. If you were using these on the old Solo/Studio/Agency plans, your lifetime access is grandfathered to the equivalent new tier.

Why

The recursive engine, structured JSON output, chat-based edits, and dual-view filtering were built for a different audience but always made more sense for AI builders. We were building this product all along — we just had the wrong target user on the box.

Architect Chat — diffable change plans

Every chat turn now produces a structured change plan you can preview before applying. No drift, no half-applied edits, no broken state.

• Preview before apply — see exactly which modules, features, and tasks will change.
• One-click apply — accept the whole plan or reject and iterate.
• Undo — full revert if you change your mind.

Recursive engine — deeper decomposition

The engine now generates acceptance criteria and dependency graphs alongside atomic tasks.

• Per-task acceptance criteria — every generated task ships with explicit "done when" conditions.
• Dependency mapping — tasks know what they depend on, surfaced for review and for export.
• Complexity flagging — high-complexity tasks get flagged for splitting before they hit your agent.

Beta access is open.

Core features

• Recursive scoping engine — turn a vague idea into modules, features, and atomic tasks.
• Project + task management — lightweight statuses (To Do, In Progress, In Review, Done).
• Dual views — different rendering modes for different audiences.
• Real-time team collaboration — multiple editors, field-level locks.
• BYOK — bring your own keys for Anthropic, OpenAI, Google, or xAI.

What's next

Architect Chat (talk to AI to refine your scope), Agent Handoff exports (one-click handoff to Cursor / Claude Code / Devin / Windsurf), and a comprehensive Builder Profile system.