After my “From Apps to Agents” post, someone asked a great question:
“While the workflow makes sense for your use case, how does it replace B2C apps—say you want to build a card game for iOS/Android?”
The answer today is: it doesn’t. But that distinction is temporary.
The Off-the-Rack vs. Bespoke Distinction (Today)
Think of it this way:
| Concept | Tailoring Metaphor | What It Means |
|---|---|---|
| Customer-facing product | The finished garment 👔 | Users interact directly with this. UI, native code, app store deployment. |
| Internal workflow | The tailoring process ✂️ | Works behind the scenes. Automations, pipelines, content generation. |
| Agents (markdown + MCP) | Automated tailoring workflows | Executing operations based on specifications |
| Compiled applications | Off-the-rack clothing | One-size-fits-all, mass-produced software |
Today, agents automate the tailoring process, not the finished garment itself.
What Agents Are For (Today)
Agents excel at workflows—and they can produce more than just text:
- ✅ Content pipelines (research → draft → review → publish)
- ✅ Code analysis and refactoring workflows
- ✅ Release notes generation
- ✅ Issue triage and routing
- ✅ Documentation updates
- ✅ Visual outputs via MCP tools: comments on GitHub PRs, popup notifications, toast messages, generated diagrams
Agents aren’t limited to text output. Through MCP tools, they can produce comments on a GitHub PR, pop up a window for the user, send a toast notification to their phone, send a text message or IM them on their favorite messaging app, or generate any visual artifact the tools support.
And here’s where it gets interesting: agents can reify GUI apps. They can write code that shows UI, and that code itself can call into a model or agent. The possibilities for dynamism are endless—only held back by operating cost and inference speed.
But Here’s What’s Coming: Generative UI and Single User Apps
The “you can’t build a card game with markdown” answer has a shelf life.
Generative UI is already here. Google’s A2UI (Agent-to-UI) framework and MCP Apps demonstrate how agents create interfaces on the fly—not just content, but entire interactive experiences tailored to individual users. This is the emergence of single user apps: applications generated at runtime, uniquely personalized for each user rather than built once and deployed to millions.
Research from 2024-2025—including work on UI code generation from specifications (arXiv:2406.00770) and design-to-code systems—shows AI generating entire interfaces from specifications: not just content, but structure, interactions, and visual design.
The pattern emerging:
| Traditional App | Generative App |
|---|---|
| Compiled code → Runtime → UI | Specification (text) → Model → UI |
| Developers write code | Developers write specs |
| Language runtime (React, Kotlin, Swift) | Model runtime (LLM) |
| System services & APIs | MCP tools |
| Static, versioned | Dynamic, personalized |
The “app” becomes a specification. The model becomes the runtime. The underlying generated code might still use React or Swift or Kotlin—but that’s not what the builder writes anymore. They write a spec.
Model Runtime Is Being Commoditized
This isn’t science fiction. The infrastructure is being built into the platforms you already use:
Chrome’s window.ai API (available in Chrome Canary/Dev) provides:
- Translator API for real-time translation
- Summarizer API for content condensation
- Writer/Rewriter API for content generation
- Prompt API for direct model interaction via JavaScript
All running locally via Gemini Nano, with no cloud calls required. See Chrome’s Built-in AI documentation.
When the model runtime is embedded in browsers, operating systems, and devices, the economics of “build an app” vs. “write a specification” shift dramatically.
The Personalization Primitive: Single User Apps
Here’s the bigger picture: generative apps aren’t just cheaper to build—they’re fundamentally different in what they can deliver.
Imagine a game that’s unique to you. It’s tailored to what you like, adapts to how you play, and evolves based on your history. This isn’t a feature toggle or A/B test—it’s a single user app generated at runtime, genuinely personalized to you alone.
The primitive that enables this: personal context and memory. Whoever solves for a system that learns personal preferences, habits, and temporal context (“what’s important to me right now”) and can monetize this as a data source for generative systems… essentially becomes the next advertising platform.
Today’s card game needs Swift. Tomorrow’s card game might need a specification and a model runtime that knows its player—creating a single user app for each player.
The Decision Framework (For Now)
Until model runtimes are performant and cheap enough:
Build an Agent When: The user is you/your team, output is text or tool-produced artifacts, and iteration speed matters more than performance.
Build an Application When: External customers interact directly, real-time responsiveness is required, or deterministic behavior is essential.
These boundaries are moving fast.
The Bigger Picture
The agent revolution today isn’t about replacing all software with markdown files. It’s about recognizing that many workflows don’t need to be apps.
But the generative UI revolution coming tomorrow? That’s about recognizing that many apps don’t need to be code.
The engineers thinking ahead are building skills in both:
- Today: Mastering agent workflows (markdown + MCP)
- Tomorrow: Understanding specification-driven generative systems
The model runtime is being commoditized into your browser, your OS, your devices. When it’s performant and cheap enough—and that’s a matter of when, not if—the card game question gets a different answer.
Key Takeaways
-
Today, agents automate workflows, not products. If customers interact with it directly, you probably need an app—for now.
-
Agents can produce visuals. Through MCP tools, agents create PR comments, notifications, popups, and more—not just text.
-
Generative UI is coming. Apps as specifications + model as runtime is the emerging pattern, enabling single user apps personalized at runtime.
-
Model runtime is commoditizing. Chrome’s window.ai, operating system integration—the infrastructure is being built.
-
Personal context is the next platform. Whoever owns preference and temporal context data for generative systems wins the personalization game.
-
Build for today, but watch for tomorrow. The “agent vs. app” line is moving fast.
This post is a follow-up to “From Apps to Agents: Breaking 18 Years of Developer Habits”. Connect with me on LinkedIn to discuss where the lines are moving.