Continuum keeps important Goals moving.

ONE CHANGING GOAL

A Goal can stay active while the plan underneath it changes.

A company needs its new website live Friday. On Tuesday, client approval is blocking the launch. On Wednesday, the client asks for updated mobile screenshots before approving anything. By Thursday, the approval is resolved, and missing domain access becomes the thing holding up production.

GOAL: Launch the website Friday
        ↓
Tuesday     client approval is blocking
        ↓
Wednesday   updated mobile screenshots are needed
        ↓
Thursday    approval is resolved
        ↓
Thursday    domain access becomes the blocker
        ↓
Same Goal. Different route. Different next move.

The individual tasks changed several times. The outcome did not. Continuum's job is to preserve that continuing situation: what the Goal is, what currently blocks it, what changed, what has already been resolved, what can happen next and where the user's involvement is actually required.

Then new information has to change the right parts of the system.

A client later says: “Move the launch to September 30. I need to approve the new photography first.” Those words can change the deadline, create a dependency, change who is waiting, and alter what deserves attention next. Receiving the message is easy. Updating the situation correctly is the harder part.

Client email
    ↓
Observation
    ↓
"Launch date changed to September 30"
"Photography approval is now a dependency"
    ↓
Epistemic reconciliation
    ↓
Owning domain accepts the change
    ↓
Goal / Responsibility / Current State / Library
    ↓
Coordinator and Home react to the new situation

Continuum should preserve where the information came from, distinguish observation from inference, detect conflicts, and let the domain that owns the fact decide how it becomes durable truth. A convincing model answer is not enough.

THE INTELLIGENCE STACK

Intelligence becomes useful when the layers around it are dependable.

Continuum is designed as a stack of distinct responsibilities. Combining them would make the system simpler to describe and harder to trust.

Observation ≠ Assertion ≠ Accepted Truth.

Context is disposable. State is durable.

DURABLE DIRECTION

Objectives can stay stable while the route keeps changing.

A task describes a piece of work. A durable objective tells Continuum what outcome still matters after individual tasks, people, deadlines, models and intermediate plans change.

                         deadline changes
                               ↓
new evidence →  [ OBJECTIVE: launch the site ]  ← new dependency
                               ↓
                     responsibilities change
                               ↓
                 next useful move changes

Objectives tell Continuum what outcome still matters.

The current backend has real Account Goals foundations. The broader Objective Engine and Objective Cell remain PLANNED. The direction is for Continuum to reason around an outcome, coordinate the highest-leverage next move, and verify whether the outcome actually moved.

Follow Up answers “don't let this fall through the cracks.”

Responsibility persistence and Account APIs already provide a durable foundation. The broader responsibility-centered experience continues to mature. A responsibility should eventually react to the world around it, so an approval that arrives early can resolve the right follow-up instead of leaving a stale reminder alive.

FROM UNDERSTANDING TO ACTION

Understanding something doesn't grant permission to act on it.

Continuum is designed for high initiative and bounded consequence. Research, reasoning, organization and preparation can be generous. Consequential work crosses a separate Authority boundary.

Change → Decision → Action intent → Authority → Runtime → Provider / system → Receipt → Durable state

Capability, credentials, a Connection, urgency and AI confidence can all exist without authorizing a consequence. The frontend never grants Authority. Runtime evaluates the current server owned Authority before a consequential step.

Capability ≠ Authority. Silence doesn't create permission. Urgency, absence or a missing reply doesn't silently widen what Continuum may do.

Standing Authority

Future user-facing modes such as Ask every time, Act within rules and Operate broadly are understandable views over exact durable grants. The stored policy still needs scope, consequence class, targets, exclusions, limits, effective time, optional expiry, pause or revocation, version history and provenance. “Operate broadly” will never mean unlimited permission.

MEMORY IS INFRASTRUCTURE

Conversation, context and world state solve different problems.

A transcript can contain guesses, stale details, abandoned ideas and corrections. Continuum therefore does not treat conversation history as the world model.

Conversation        what was said
Context Run         what one reasoning execution was allowed to see
World / domain state what Continuum currently accepts as true

Conversation preserves durable multi-turn history and eventually message/version/response-variant lineage. Context Run records the bounded context assembled for one AI execution. World and domain state preserve accepted truth with provenance and history.

The canonical Account-native Library is LIVE for normal signed-in Accounts, with durable content, Draft editing, immutable Versions, literal search, folders, pagination and conflict recovery. The governed epistemic promotion bridge is now LIVE as a production backend foundation for evidence → assertion → reconciliation → domain-owned acceptance. Library is the first proven promotion vertical and still requires explicit confirmation by the owning Account; automatic learning from Coordinator conversations is not yet a released behavior.

Memory Center and the broader automatic learning experience remain PLANNED. The underlying architecture is deliberately being built first so “memory” does not become a second ungoverned truth database.

REPLACEABLE INTELLIGENCE, DURABLE CONTINUITY

Continuum does not need to permanently own the smartest model.

It needs to reliably assemble, direct, constrain, remember and verify the smartest intelligence available for the job.

                       ┌─ planner
Objective + State ────┼─ researcher
                       ├─ critic
                       ├─ coding model
                       └─ domain specialist
                              ↓
                         reconciliation
                              ↓
                           Continuum

Continuum knows more than every individual AI needs to know. A broad planner may receive more Goal context. A researcher may receive one question and its evidence. A coding model may receive repository and task context. Context disclosure should follow purpose, privacy, least privilege, provider boundaries, cost and focus.

Coordinator reasoning is already provider-backed through the canonical AI Gateway, and Product Self-Knowledge is LIVE. For ordinary turns, the model receives a small deterministic grounding contract. Product, setup, capability and roadmap questions can receive richer verified Product Self-Knowledge scoped to the Account. Model prior knowledge is not product truth.

Connections turn external change into usable evidence.

The current protected Connections experience supports real provider readiness and health evidence. Broader Gmail, Calendar and Google Drive ingestion is PLANNED. The goal is not to expose more APIs. Connected information should become durable objects, observations and relationships that improve future coordination.

WHEN THE USER ISN'T THERE

Continuity should survive a closed browser without silently widening permission.

Check In is a LIVE bounded continuity capability. It keeps timing policy and Incident history server owned. Broader unattended consequence processing still depends on worker reliability, explicit Authority and production proof.

CURRENT PRODUCT TRUTH

One product, different levels of maturity.

A backend foundation, a released browser surface and a proven autonomous outcome are different milestones. This document uses the same maturity language Coordinator is being taught to use.