Product direction Delegation, not configuration

From apps to delegated goals

A product direction for agentic software where the user delegates an outcome, useful software appears around that goal, and the agent keeps working.

The mental model is the product

The key shift is not “AI can build apps.” It is “software can take responsibility for an outcome.”

Software as product

I want something ↓ I describe an app ↓ AI builds it ↓ I configure it ↓ I use it

→

Software as medium

I want an outcome ↓ I delegate it ↓ Something useful appears immediately ↓ The agent keeps working on it

The mini app UI should materialize around the goal as a useful visual workspace. It is a representation of the delegation, not the thing being created.

Change the unit from “app” to “delegated responsibility”

Internally we can still have agents, runtimes, schemas and generated UI. Consumer-facing language should describe goals and responsibility instead.

Current mental model	Better mental model
Create an app	Start a goal
Build something	Let AI handle something
Customize app	Adjust how this works
Save app	Keep this running

Have an outcome catalog, not an app catalog

When the system does not have enough context to suggest something specific, discovery should still be framed around what people want accomplished.

Fitness tracker→Get back in shape

Travel planner→Plan my next trip

Habit tracker→Build a morning routine

Budget dashboard→Get my spending under control

Suggestions should be results, not prompts

Prompt-first

“Create an app to manage my household”

“Build a fitness tracker”

“Make a trip planner”

Outcome-first

Run my household
See what this does

Train for a 10K
Set up

Plan my next trip
Set up

Customization should change the goal experience, not “edit the app”

UI editing language makes the experience feel like vibe coding. Semantic preferences feel like teaching an agent how to handle a responsibility.

Feels like app development

Add a button here

Change this flow

Make this chart bigger

Feels like delegation

Always show me the budget first

I don’t care about calories, hide them

Let me approve workouts one day at a time

Ask me before changing reservations

Compare everything against my previous month

Share the playbook, not the app

Users share reusable ideas for achieving specific goals—agent instructions, tools, triggers, policies and workflow logic. The system then adapts each playbook to the user’s own context.

Train for a half marathon

goal model
domain schema
agent instructions and policies
triggers
allowed tools
UI grammar
useful actions
lifecycle logic

“Start this for me”

The system adapts the playbook using my health data, schedule, fitness history, preferences and memory.

The shared object is the strategy. The resulting experience is personal.

Conceptual stack

The generated web document should not become the canonical application state. It is a representation of persistent goal state.

Connections
Calendar, email, health, finance, location, services
                    ↓
Shared Personal Context
facts + preferences + relationships + history + permissions
                    ↓
Goal Opportunity Engine
“What is currently worth helping this user with?”
                    ↓
Goal Kit
domain schema + tools + agent playbook + triggers
UI grammar + onboarding + approval policy
                    ↓
Persistent Goal State
objects + plans + decisions + progress + history
              ↙                    ↘
     Agent Runtime            UI Composer
              ↘                    ↙
             Goal Workspace
      persistent adaptive mini-app
                    +
             Agent Conversation
                    ↓
Actions / approvals / results
                    ↓
Shared events + selected memory

Three product models

Traditional software

User finds app Learns app Enters data Operates workflow Gets outcome

Vibe-coded personal software

User discovers need Specifies software AI builds app User configures app Operates workflow Gets outcome

Goal-oriented agentic software

Context + user define goal Agent prepares useful state Personalized workspace appears User confirms or corrects Agent operates toward outcome UI evolves when useful

Don’t build a platform where users make personalized apps.

Build a personal agent ecosystem where users delegate goals, and personalized software materializes around those goals when software is useful.

Your apps shouldn’t be software the user builds. They should be goals the system learns to take care of.