Product Vision & Architecture

1. Product Overview

1.1 The Paradigm Shift

The software industry has operated under a deeply flawed assumption for decades: that software is the primary artifact of product development. Business requirements get translated into technical specifications, handed to engineers, built in isolation, and returned to business owners who often find it does not match their original vision.

Assembly challenges this at the root. Software becomes invisible infrastructure. The product — the outcome, the user experience, the business value — is all that matters.

1.2 Vision

A world where anyone with a business idea can bring a working product to life through natural conversation — where the distance between imagination and a live, deployed application collapses to a single Assembly session.

1.3 Mission

To eliminate the gap between business imagination and working software by creating the world's first AI-powered collaborative Assembly platform — where multi-human, multi-agent live sessions replace the entire traditional software development lifecycle.

1.4 Key Design Principles

• Product First: The product outcome is the only artifact anyone should see or care about. Software is a black box.
• Voice First: Natural speech is the primary input mode. Typing is optional; clicking is delegated to agents.
• Session as Lifecycle: One evergreen session link is the entire life of a product — from ideation through production monitoring.
• Timeline Not Versioning: Instead of branches and merges, Assembly uses an immutable time-based state log. Any state can be restored by navigating to a point in time.
• Web Native: Assembly targets web applications (JavaScript/HTML DOM) exclusively in v1. Mobile, game engines, and embedded hardware are out of scope.
• Leased Intelligence: Assembly does not train models. It maximizes value from frontier model subscriptions (Claude, GPT, Gemini) through expert agentic orchestration — which is the core IP.

2. Critical User Journeys (CUJs)

The following seven journeys represent the complete lifecycle of a product built on Assembly. Each CUJ maps to one or more technical modules and product phases.

CUJ-1: Initiating a Product Assembly Session

Who: Business Owner, Product Manager, invited collaborators. Trigger: a business owner wants to build a new product or feature.

1. User creates a new Assembly session — receives an evergreen session link
2. User assigns participant roles and sends invitations
3. AI agents auto-join based on session context (PM Agent, UX Agent, Tech Agent active by default)
4. Session begins — Phase Barometer shows: Ideation

Success: all participants in session, agents listening, Phase Barometer visible.

CUJ-2: AI-Guided Ideation & Requirements Capture

Humans converse freely about their product idea. AI agents listen passively and extract structured product requirements in real time.

• PM Agent: extracts product type, critical user journeys, pain points, feature priorities, success metrics, and risks
• UX Agent: identifies user flows, accessibility needs, friction points, and delight opportunities
• Tech Agent: notes infrastructure needs, integration risks, and module boundaries
• Turn-Taking Engine: when conversation is one-sided (e.g., only UX discussed), the relevant agent interjects with a probing question
• Phase Barometer: updates in real time showing readiness percentage toward prototype threshold

CUJ-3: Live Prototype Generation

When the Phase Barometer crosses the prototype-ready threshold, the product materializes in front of the assembly while the conversation is still happening.

1. Agents synthesize all captured requirements into a structured product spec
2. Code Generation and UI/UX Generation models generate the web application code
3. Prototype Renderer embeds a live browser instance within the Assembly session
4. Participants see a working, interactive prototype rendered in real time — not a mockup
5. App Agent (Playwright) demonstrates the prototype by navigating it on screen
6. Phase Barometer advances to: Prototype

CUJ-4: Collaborative Feedback Loop

Participants react to the prototype verbally. The session becomes a feedback-driven iteration loop.

• Participant says: "This button should be blue, not green" — UI Agent applies the change
• Participant shares their screen highlighting a section — Screen Annotator captures visual context
• Multiple participants provide concurrent feedback — Turn-Taking Engine manages the floor
• App Agent clicks through the app demonstrating changes on screen
• Timeline Manager records each state as an immutable checkpoint
• Phase Barometer can advance to Enhancement or retreat to Feedback

CUJ-5: Milestone Progression — Prototype to Deployment

When the assembly is satisfied, the product advances through deployment phases. Environment Agent personas activate.

Participants naturally direct their conversation to the appropriate environment agent. The system routes queries automatically based on intent — no participant needs to know which agent to address.

CUJ-6: Ongoing Product Lifecycle via Evergreen Session

The session link is permanent. Any authorized participant can join at any time throughout the product's entire life.

• Product Manager joins to check metrics — Prod Agent surfaces DAU, errors, ticket trends
• Business owner returns after a month — sees current live state, reviews Timeline for what changed
• Security vulnerability detected — Assembly session drives the patch through Dev → UAT → Prod
• Year-end enhancement planning — new features discussed and built in the same session
• Retirement of legacy features — managed through the same interface that created them

CUJ-7: Asynchronous Stakeholder Catch-Up

Stakeholders who were absent from a session can rejoin at any time and see the current state. No manual catch-up documents, no review meetings.

1. Stakeholder opens evergreen link — sees current product state and Phase Barometer
2. Reviews Timeline: "what changed since I was last here" — agents summarize delta
3. Provides new direction, raises concerns, or approves current state verbally
4. Their contributions are captured and attributed in the Timeline

3. Solution Architecture

The Assembly platform is organized into six architectural layers. The Agentic Orchestration Engine is the core IP. All other layers either feed into it or execute its instructions.

3.1 Architecture Overview

3.2 Data Flow

Voice and screen input from participants flows into the Session Engine, which converts it to structured context (speaker-attributed text with role metadata). The Agentic Orchestration Engine receives this context stream and routes it to the appropriate agent personas. Agents process their domain slice, collaborate with peer agents, and instruct the Frontier Model layer to generate or modify code. The Prototype Renderer reflects changes in the live browser. All state changes are persisted to the Data Foundation with immutable Timeline snapshots.

The loop is continuous: agent outputs return to the session (via voice/text response or prototype update), participants react, new context flows in. No step is manual. No deployment script is visible.

3.3 The Agentic Orchestration Engine (Core IP)

This is what Assembly will patent, protect, and continuously improve. It is not a chatbot or a copilot. It is a multi-agent coordination system with the following responsibilities:

• Context Routing: parses incoming context (voice, annotated screen, chat) and determines which agent(s) should process it and in what order
• Phase Management: maintains the readiness model across 6 phases and triggers transitions automatically when threshold conditions are met
• Turn-Taking: manages the conversation floor — prevents agents from interrupting humans, arbitrates between agents, enables probing questions at the right moment
• Agent Orchestration: dispatches tasks to agents, collects their outputs, merges conflicting inputs (e.g., two participants disagree), and produces a unified instruction to the model layer
• Timeline Custody: writes every state transition as an immutable event to the Timeline — the single source of truth for the entire product history

4. Technical Modules

The following 15 modules constitute the complete technical implementation of Assembly. Each module is annotated with the development milestone in which it is first introduced.

4.1 Screen Annotation Processor (Supporting Module)

When a participant shares their screen, this sub-module captures the stream, processes highlighted or pointed-at regions using computer vision, and generates structured visual context (e.g., "region: top navigation bar, instruction: change background to navy"). This feeds the UI Agent without requiring participants to type descriptions.

4.2 Notification & Reconvene Coordinator (Supporting Module)

When the Agentic Engine completes a significant background task (prototype generated, vulnerability patched, UAT completed), it triggers the Notification Coordinator. This module sends calendar invites to the assembly group, emails, and in-app notifications — automatically scheduling the next review session so no human has to manage the iteration cycle.

5. Iterative Milestones (Crawl → Walk → Run → Fly)

The product will be built iteratively. No throwaway work — each milestone is a foundation for the next. The goal is a delightful, demo-ready product for the first 5 beta customers (VC adjacents) by Milestone 4.

6. Open Questions & Research Priorities