Mosaic: Rethinking App Design for the Multi-App Era

We live in a world where apps are still siloed products. App stores want you to search, install, and learn them one by one. But our lives don't fit into silos. We live in flows — trips, health check-ups, courses, projects — and those flows cut across dozens of apps.

What is Mosaic?

At its core, Mosaic is a vision:

• Instead of monolithic apps, we think in tiles — small modular capabilities.
• A user's intent ("I'm visiting Tokyo") becomes the starting point.
• The right set of tiles assemble into a cohesive app, just for that journey.
• And as your journey changes, the app reshapes itself.

How Mosaic assembles the right capabilities for your specific journey

In the coming parts of this series, I'll unpack this vision step by step.

What This Series Will Cover

Why Start Here?

Before we can imagine a new model, we need to clearly see what's broken today:

• Too many apps. Every task means juggling 3–5 different tools.
• Too much friction. Search, install, learn, delete. Repeat.
• Too little adaptability. Apps don't evolve with your journey.

Mosaic is my attempt to rethink this from the ground up.

Homework for You

Before the next part, here's a simple exercise:

The Challenge of Today's App World

The endless cycle of app hunting and learning new interfaces

Every time you need something new, you're pushed into the same cycle:

Take translator apps: the store is full of them, all doing roughly the same job. But as a user, you still need to guess which one is "best," install it, and learn yet another interface — even though what you really want is just translation within your current flow.

It's a never-ending battle of app hunting and app learning.

What Makes App Flows Different

App Flows, by contrast, are dynamic and adaptive. They:

• Highlight what matters most right now.
• Fade out or remove tiles that are no longer relevant.
• Rearrange themselves automatically as your context shifts.

The Tokyo Trip Example

A Living Companion that evolves as your context changes

Let's imagine you're planning a trip to Tokyo.

🗂️ Beyond the trip: Disposable & Archivable Flows

Defining App Flows and Mosaic

To be precise:

Why Adaptive Journeys Matter

With Mosaic-driven App Flows:

Homework for You

The Core Building Blocks

To make App Flows real, Mosaic relies on four components:

The four core building blocks that make Mosaic App Flows possible

// logic.ts
export async function getWeather(location: string) {
  const response = await fetch(`/api/weather?loc=${location}`);
  return await response.json();
}

<!-- WeatherTile.svelte -->
<script lang="ts">
  export let weather: { temp: number; condition: string };
</script>

<div class="tile card">
  <h3>Weather</h3>
  <p>{weather.temp}°C — {weather.condition}</p>
</div>

{
  "name": "WeatherTile",
  "version": "1.0.0",
  "provider": "Community",
  "logic": "./logic.ts",
  "presentation": {
    "modes": ["card", "widget"],
    "component": "./WeatherTile.svelte",
    "props": {
      "weather": "object"
    }
  },
  "metadata": {
    "context": ["travel", "daily-life"],
    "priority": "medium",
    "pairsWith": ["MapTile"]
  }
}

Why PWAs Are the Bridge

We don't need to invent a new OS to make this work. Progressive Web Apps (PWAs) already give us:

• Self-updating behavior (Service Workers).
• Cross-platform reach (runs in browsers, mobile, desktop).
• Installability (can live on the home screen or open via link).
• Offline support (cached tiles, limited resilience).

PWAs are the perfect near-term vehicle for Mosaic — an App Flow could be shared as a link, installed instantly, and evolve dynamically.

PWA Limitations

• Limited access to device APIs (push, Bluetooth, sensors).
• Discoverability bias (native apps favored in app stores).
• On iOS, stricter background and storage restrictions.

So while PWAs can't yet replace every native app, they can already demonstrate the App Flow model in practice.

The Role of LLMs

The LLM-powered Context Engine is what ties it all together:

The result: a persistent, adaptive App Flow that evolves with you, rather than static apps you have to juggle.

Why This Matters

With these pieces, Mosaic is not science fiction. Using today's tech:

• Logic can be written as functions or API wrappers.
• UI can be packaged as components.
• Manifests can live in a registry (like NPM for tiles).
• PWAs can deliver adaptive App Flows cross-platform.
• LLMs can interpret user intent and orchestrate flows.

Together, they transform apps from static silos into Living Companions that grow and adapt with your context — location, time, role, and goals.

Homework for You

How Mosaic Works as a PWA

At first, Mosaic can be implemented as a single container PWA hosted at {abc.com}.

When you install Mosaic once (from {abc.com}), you get the wrapper app that includes:

• Context Engine → interprets user goals.
• Tile Registry client → fetches logic, UI components, and metadata.
• Composer → assembles tiles into an App Flow and renders it.

Each App Flow is just a route inside this PWA.

All three share the same manifest, service worker, and scope.

{
  "name": "Mosaic",
  "start_url": "/",
  "scope": "/appflow/"
}

The Near Future: Hosted Registries

At the start, websites like {abc.com} can host Tile Registries and Flow Builders:

• Developers publish reusable tiles.
• Users combine tiles into App Flows via a simple web builder.
• Flows are shared as URLs.

Multiple providers could host registries — just like multiple app stores exist today.

Some registries may specialize (travel, fitness, education), while others remain general-purpose.

The Long-Term Goal: OS-Level Mosaic

Over time, Mosaic could move deeper into the operating system, just like app stores and file explorers did.

• The Tile Registry becomes part of OS settings (where you choose which registries to trust).
• App Flows become OS-native adaptive apps, disposable and self-updating.
• Users don't manage dozens of installs. They simply trigger flows by expressing goals.

This is where Mosaic diverges from MCP (Model Context Protocol):

Mosaic = chatless orchestration + goal-driven adaptive apps.

The Roadmap

Why This Matters

PWAs let us build Mosaic today — with one container app and flows as routes. Hosting registries at sites like {abc.com} lets users and developers experiment now.

But the long-term vision is bigger: Mosaic as an OS-native orchestrator, with registries managed at the system level. Unlike MCP's chat-first approach, Mosaic enables goal-first disposable apps that adapt and disappear when finished.

Homework for You