Architecture that stays connected to delivery

Keep your architecture aligned with what your team and AI actually build.

Design your system visually, store it as reviewable YAML, and give developers and AI agents a shared source of truth as the platform evolves.

Create a free Sphere account Explore the live editor

Discover the open SCAN notation →

sphere · approved architecture model

A living system blueprint — not a disposable diagram

Architecture loses value when it stops reflecting reality.

Traditional diagrams are easy to create and easy to forget. As code changes, the documented system and the real system drift apart. Developers lose trust in the diagrams, architects lose visibility, and AI agents generate changes without understanding the platform as a whole.

Stale diagrams

Documentation no longer represents the implementation.

Fragmented decisions

Teams build from local context instead of shared system intent.

Ungoverned AI output

Coding agents optimize individual tasks without knowing architectural boundaries.

Living source of truth

From passive diagram to active system blueprint.

SCAN describes what exists and how it is connected. Sphere Flows describes what happens across those connections. Sphere makes both visual, understandable, and actionable.

Model

Design a greenfield system or map an existing implementation in Sphere.

Explain

Use Sphere Flows to trace how requests, events, data, and exception paths move through the system.

Review

Store architecture and flows as structured, versioned artifacts and review changes through Git like code.

Guide delivery

Use the approved model and flows to inform developers, plans, validations, and AI coding agents.

Sphere Flows

See how the system behaves, not only how it is structured.

A component map shows what the platform contains. Sphere Flows shows what happens across it: which service receives a request, where data is read or written, which event is published, how an asynchronous process continues, and what happens when a step fails.

Trace end-to-end behavior
Follow a request, event, or business scenario across multiple components.
Reduce diagram overload
Reveal only the connections and steps relevant to the selected scenario.
Document happy and failure paths
Make retries, fallbacks, timeouts, queues, and dead-letter paths understandable.
Give AI agents behavioral context
Communicate not only which components exist, but how they are expected to collaborate.

sphere · flows-overlay

Walk a named scenario on the board — click to watch the full demo.

Role vs technology

Model what a component does, not only what it runs on.

A service remains a service whether it is implemented with Spring Boot, NestJS, or another technology. SCAN separates architectural role from implementation choice, keeping the model stable while the stack evolves.

type: service

technology: Spring Boot → NestJS

Architectural relationships stay the same.

Git-native

Review architecture changes like code changes.

Every diagram is backed by structured YAML. Version it in Git, inspect the diff in a pull request, and make architectural decisions part of the engineering workflow rather than a separate documentation exercise.

- type: service
- technology: Spring Boot
+ type: service
+ technology: NestJS
  exposes:
    - protocol: OpenAPI

Sphere Enterprise

Give every AI coding agent the architecture it must respect.

AI coding tools usually see only the current task and a limited part of the codebase. Sphere Enterprise uses the approved architecture and its behavioral flows as persistent system-level context, helping AI harnesses plan, generate, and validate changes within the platform’s intended boundaries.

Available today: Ask Sphere, architecture warnings, SCAN YAML round-trip, and Sphere Flows in the product. Product direction: continuous Cursor Plan/Build harness governance (preview / quotation — not generally available on the public site).

Available today

Shared context

Developers and AI agents work from the same approved system model and behavioral scenarios.

Available today

Bounded generation

Agents can receive relevant components, contracts, dependencies, and flows before modifying code.

Product direction

Continuous alignment

Implementation changes can be checked for architectural drift as platforms evolve.

Product direction

Behavior-aware validation

Generated changes can be evaluated against expected happy paths, failure paths, and cross-component interactions.

Available today

Governed evolution

Proposed architecture changes remain visible, reviewable, and auditable.

Product direction

Tool independence

The architecture remains the source of truth even when teams use different coding agents or models.

Talk to us about Sphere Enterprise →

SCAN · open notation

The open notation beneath Sphere.

SCAN is a technology-independent YAML/JSON metamodel for software systems — services, datastores, streams, agents, repositories, and typed connections. Sphere reads, writes, and validates it as the shared architecture model.

Read the SCAN docs →

checkout.scan.yaml

scan: "0.1"

scan: "0.1"

components:
  - id: checkout-api
    name: Checkout API
    type: service
    technology: NestJS
    exposes:
      - id: checkout-api-out
        label: REST
        protocol: OpenAPI

connections:
  - id: c1
    from: payments
    to: checkout-api
    type: synchronous-request

Adopt the parts you need

Modular open-source packages.

Use the notation, renderer, validation rules, or complete workspace independently. SCAN is free and open; Sphere is the visual and operational product built around it.

@spherescan/model

Parse / serialize / validate SCAN YAML & JSON

@spherescan/rules

Legal connection pairs + port checks

@spherescan/viewer

Model → board graph; SVG/PNG export

@spherescan/modeler

Command stack: move, connect, create, auto-layout, undo

@spherescan/board

Interactive React canvas (whiteboard + host apps)

@spherescan/cli

validate, export svg, …