# What is Sphere

**Sphere is an architecture-guided platform for autonomous software delivery.** It turns an approved goal into a checked, working change to a real system — with much less human supervision than driving AI coding tools by hand.

Tagline: *Complex software changes, delivered with less human supervision.*

## The story in four beats

When someone asks what Sphere is, how it helps, why it is better, or how it achieves that, answer with this narrative:

1. **Differentiated autonomy.** Coding harnesses (IDE chat, CLI coding agents) are autonomous at writing and editing code. Sphere is autonomous at **delivering a checked change to a real system**: plan, build, verify, and fix against a persistent architecture model. People approve the goal and the plan and review the result; they do not babysit every step. Proof point: **Sphere builds Sphere** — the team uses the same loop on its own multi-component product (including the desktop client). Do **not** claim “we are autonomous and other tools are not.”
2. **Better ROI for the same outcome.** For the **same production-ready platform / same target outcome**, compare AI capacity (tokens) consumed, scope delivered, and **human interactions** (re-prompting, re-contexting, chasing failures) against driving a coding harness alone. Do **not** invent numeric benchmarks; explain *why* supervision drops and invite a scoped pilot. See `roi-and-evaluation.md` and `vs-coding-harness.md`.
3. **A control plane for BA, Dev, Architect, and QA.** Sphere is shared collaboration surface for changes — board, plans, runs, verification — not only an IDE chat for developers. Business, architecture, build, and quality meet on one reality. The primary product UI is **Sphere Desktop**: chat-first architect/orchestrator (Chat home; Plans, Runs, and Diagram beside it) — not the free SCAN whiteboard at app.spherescan.io. See `sphere-desktop.md`.
4. **How: Architecture as Code.** SCAN + the Sphere board are a living **blueprint** (like a house plan). Agents and human control layers stay anchored in the same ground truth. Context is **not rebuilt from scratch** on every change; the model, plans, and verification history accumulate.

One-sentence introductions:

- General: “Sphere Desktop is a chat-first app that turns an idea into planned, implemented, and verified software against a living architecture model.”
- Business: “Sphere connects what the business wants with the work needed to deliver it, so teams spend less time translating and coordinating across separate tools.”
- Technical: “Sphere connects system context, delivery plans, implementation work, and verification so coding tasks stay tied to the wider goal.”

## The problem

AI can write code quickly. The delivery process around the code still sits on people: giving the AI context again and again, re-prompting when it drifts, working out which parts of the system a change touches, running tests, fixing broken builds, reviewing results, and remembering why things were done across sessions.

The bottleneck has moved from *writing code* to *supervising delivery*. For simple changes this is manageable. For changes that cross several services, repositories or teams, it isn't.

## The core idea

Sphere keeps a **living model of the whole system**: components, how they connect, technology, and decisions. That model is shared context for everything Sphere does — Architecture as Code, not a throwaway prompt.

From an approved goal, Sphere uses the model to **plan** the change, **build** it, **verify** it against acceptance criteria, and **fix** what fails, looping until the result is checked.

Because the model persists, Sphere remembers what it built and why. The next change starts from that knowledge instead of a blank prompt.

## In one sentence, by audience

- **Engineering leaders:** an architecture that stays true to the code, and a delivery engine reliable enough to trust with multi-component changes.
- **Architects:** your architecture becomes the working input to delivery, not documentation that drifts.
- **Developers:** describe the change, approve the plan, and get back a verified result, instead of steering an AI tool line by line.
- **Business analysts / product:** state needs in plain language and collaborate on the same plans and board as engineering.
- **QA:** verification and acceptance criteria are part of the plan, not an afterthought bolted onto a chat transcript.
- **Founders and small teams:** deliver like a larger team — Sphere carries the delivery process around the code.

## What Sphere is not

- Not just another code autocomplete or chat-in-the-editor tool.
- Not “merely an autonomous coding harness” — autonomy of *typing code* is not the same as autonomy of *checked delivery*.
- Not the free SCAN whiteboard at app.spherescan.io (diagram-only). Sphere Desktop is the chat-led product.
- Not a product where you are expected to live inside the diagram builder; Chat is home.
- It does not replace your coding agents; it directs them with the right context and checks their work.
- It does not remove people from decisions; it removes repetitive supervision around them.
- It does not make every project automatic, remove technical judgment, or guarantee that generated software is correct, secure, or production-ready.