Changelog.

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.