Vision

Software that can be asked for, and can answer for itself.

The end state is not a chatbot in a business app. It is a business app where the durable outputs — reports, views, documents, data models — can be requested in language, produced under supervision, and then live on as first-class objects that anyone can find, trust and reuse.

The bet

Business software has always been constrained by who could build the thing.

A CMS lets a team publish a page. A spreadsheet lets an analyst build a model. But "a report that breaks down by region and refreshes every Monday, scoped to whoever is looking at it" has always needed an engineer. The compounding waste is not the coding — it is that the answer is never captured as a thing. It lives in a chat, a slide, or someone's memory.

Today

Ask, transcribe, forget

  • The request arrives in chat, so the answer leaves in chat.
  • The next person asks the same question and gets a slightly different answer.
  • The numbers have no provenance, so nobody can audit them.
  • Access is whatever the last person who exported it happened to have.
With Siteplan

Ask, publish, rely on it

  • The request becomes a task with an owner, linked to an objective.
  • The result becomes an artifact with versions, a source topic and an audit trail.
  • The data is a declared dataset executed as each viewer, so scope is enforced by construction.
  • Anyone with access can pin it, and it stays correct as people and membership change.
The artifact outlives the conversation that produced it. That single property is the difference between a demo and a system of record. Design intent
Where it goes

Four directions, each already reachable by design.

None of these require a rewrite of the core. That is the test of the seams: the next capability should be an addition, not a migration.

01 · Portability

Move a conversation between engines

A topic stores provider-neutral events, so the runtime is chosen per run. Credit exhaustion, a better model or a cheaper engine becomes a switch instead of a fork. The resolver already keeps a slot for an automatic router that chooses on budget, cost, capability or model — and records why, so a routed choice stays auditable.

02 · Containment

Choose isolation per organization

The same adapter runs in-process, in a subprocess, in a filesystem sandbox, in a container or on a remote VM. Placement is an organization policy with a resolution chain and a fail-closed validation. A container host is the top tier, not the entry fee.

03 · Autonomy

Let work happen when nobody is in the room

Scheduled, event-bound and objective-bound triggers let an agent maintain a report, watch a threshold or prepare a review — bounded to one hop, with an accountable human owner and a per-organization rate limit.

04 · Ownership

Model your own domain without a deploy

User-defined apps with relationships and permanent storage, on JSON records by default and governed physical tables when volume demands it. The registry is the schema, and an idempotent sync applies it.

Principles

What decides the trade-offs.

These are not aspirations. Each one has already rejected a plausible alternative, and the rejection is recorded in the design.

01

Separate the stream from the state

The event log is append-only and authoritative. Canvases, artifacts, pins and tasks are projections that can be rebuilt. A product that treats the current view as the truth cannot replay, cannot audit and cannot recover.

02

Parity in the stream, asymmetry in the power

Agents are addressable senders with audit records, and they can be assigned work exactly like a person. They never authenticate and never hold human permissions. Every agent has a human owner who answers for it.

03

A pin is a placement, never a grant

Visibility is access. If placement granted access, any member of any team could publish into any other team by pinning. Data is executed as the viewer, so the same pin can legitimately show different rows to different people.

04

Never let the model be the security boundary

An agent that can write SQL can read anything the connection can reach. Datasets are validated specs, tools are admitted by capability, and grants are checked where the write happens — not where the prompt is built.

05

Fail closed, and make the failure visible

An isolation floor never falls back to a weaker placement. A broken refresh never blanks a pinned report. A missing permission renders a permission state, not a partial answer. An admin cannot believe they have a boundary they do not have.

06

Separate the axes, then compose them

Engine and placement. Capability and data scope. Canvas, artifact and pin. Runtimes and worker processes. Collapsing an axis buys a week and costs a migration.

07

Split only on a concrete trigger

No service is separated in anticipation. One process owns the schema, the auth plane and the event log until a real scaling, runtime or compliance trigger says otherwise — and the seam is already in place for when it does.

08

Keep the vocabulary honest

A tenant is an Organization, a Team is a Team, and Workspace means only the UI shell. A word that means two things is a bug that ships in every future conversation about the system.

Maturity

Honest about what is built.

A design that cannot be partially shipped is not a design. Siteplan is delivered in slices, each independently verifiable, each leaving the existing tests green.

Today the foundation exists: the ASGI application, the actor flag, the organization event log with one write path, the WebSocket consumer with replay and resume, and a working workspace with a CLI agent speaking the Agent Client Protocol.

The product layer — objectives, tasks, artifacts, pins, datasets, approvals and triggers — is specified in full and scheduled. The specification is the contract; the slices are how it arrives.

Built
ASGI + Channels event log actor flag WS replay workspace ACP agent placements
Specified
G-SDUI canvas approvals grants artifacts pins datasets triggers dynamic apps
Future
automatic routing remote placement external data sources
The reference scenario is the contract. Twelve steps from a human request to an organization-wide pinned artifact. Every one of them has to work on the same domain model — that is how the design is judged.
In one sentence
A business application where the work, the data and the agents that act on them share one log, one authorization plane and one accountable owner — so an answer that was asked for once becomes something the organization can keep.

Read it from the top, or go straight to the reference scenario.