AI-Native Platform Architect

Help me rethink this product from the ground up as an AI-native platform.

This is a greenfield product, systems, and architecture exercise. I want to define the platform from first principles, not as a conventional software product with AI features layered on top, but as a system whose core primitives are native to intelligence, memory, sessions, tools, artifacts, and persistent work.

## Core framing

This platform should be designed as an AI-native operating environment. The primary unit of interaction is not a static page or CRUD object, but an active session of intelligence operating over a persistent workspace or state substrate. Agents are active actors in the system. Memory, artifacts, events, tools, and the workspace itself are first-class primitives.

## Design goal

Produce a deeply reasoned proposal that defines:

- the product vision
- the conceptual model
- the core primitives
- the data model
- the runtime architecture
- the onboarding flow
- the UX principles
- the key pages or surfaces
- the implementation sequence required to build it coherently

Use relevant references for:

- onboarding and narrative simplicity
- AI-native interaction design
- progressive disclosure
- workspace/session interaction
- agent-centric UX

But do not imitate any one product directly. Reframe the design around this platform's own ontology and purpose.

## Reasoning order — inside out

You must reason from the inside out:

1. define the core primitives
2. define the system ontology
3. define the entity model and relationships
4. define the runtime and persistence model
5. define the UX and page/surface architecture
6. define the onboarding and narrative flow
7. define the implementation order

Do not start with screens alone. Start with primitives and operating model.

## Core primitives — explicit definition required

Please explicitly define the core primitives for the platform. Depending on the domain, analyze candidates such as:

- User
- Workspace
- Session
- Agent
- Runtime
- Tool
- Memory
- Knowledge graph
- Artifact
- Document
- Operation
- Run
- Event
- State snapshot
- Policy
- Identity boundary
- Tenant / organization
- Environment
- Task / objective

For each primitive, define:

- what it is
- why it exists
- how it persists
- what it relates to
- how it appears in the UX
- how it participates in runtime behavior

## Required output sections

Then define:

### 1. Product architecture
- what the platform fundamentally is
- what makes it AI-native
- how it differs from conventional software

### 2. Data architecture
- canonical entities
- relationships
- event model
- state model
- memory and artifact model

### 3. Runtime architecture
- how sessions are instantiated
- how agents operate
- how tools are invoked
- how memory is updated
- how artifacts are created
- how operations are registered

### 4. UX architecture
- onboarding flow
- first-run experience
- workspace/session interaction model
- feature discovery
- progressive disclosure
- how intelligence is made legible to the user

### 5. Narrative and presentation
- how to explain the system clearly
- how to make a complex AI-native architecture feel simple
- how the product story should unfold from first contact to first successful run

### 6. Implementation implications
- what must be built first
- foundational abstractions that cannot be skipped
- what should be deferred
- common traps that collapse the platform into a conventional app

## Constraints — what NOT to do

- do not design this as a standard SaaS dashboard with AI added on top
- do not reduce the product to a chat interface only
- do not ignore memory, runtime, and state as first-class concerns
- do not start from UI polish before core ontology is defined
- do not conflate history, memory, artifacts, and operational state without clear boundaries

## Output format

Provide a structured proposal with:

1. platform definition
2. core primitives
3. entity and relationship model
4. runtime and persistence architecture
5. onboarding and UX architecture
6. narrative and design principles
7. recommended greenfield implementation sequence
8. key tradeoffs and open questions

Think deeply and step by step across the chain of dependencies. The goal is to define an AI-native platform whose architecture is coherent at the level of ontology, runtime, memory, and user experience.