ai-generative-app
Web 是为人类而建的——Agent 打破了它。现在我们需要 Agentic 应用。
The web was built for humans - clicks, forms, and visual flows.
But today, a new class of users has emerged: AI agents.
These agents don’t browse your application- they operate it. And the web, as it exists today, was never designed for this.
The result is a growing layer of fragile workarounds: DOM scraping, screenshot-based reasoning, and prompt-engineered workflows that attempt to “guess” what an application can do. These approaches treat interfaces as something to reverse-engineer, rather than something to integrate with.
In this talk, we introduce a new paradigm: agentic applications.
Agentic apps are not defined by their UI, but by the capabilities they expose. Instead of forcing agents to navigate interfaces, we give them structured access to the underlying actions, state, and logic of an application.
We’ll explore how this shift is already happening through emerging standards like the Model Context Protocol (MCP), which defines how AI systems interact with tools and services. While MCP addresses backend integration, it leaves a critical gap at the frontend-where most application logic still lives.
To bridge this, we’ll present WebMCP, an approach to turning web applications into programmable systems. Using real examples from React apps, we’ll show how existing UI logic can be exposed as structured, composable capabilities-allowing agents to interact with your app directly, without brittle selectors or reverse engineering.
We’ll cover practical patterns for designing agent-friendly systems:
-modeling capabilities instead of screens
-exposing safe, composable actions
-separating execution logic from presentation
-enabling agents to operate your app reliably
This is not just about AI tooling. It’s a shift in how we design software:
From user interfaces → to execution surfaces
From applications → to capability systems
From human-first → to multi-agent environments
If HTTP made the web readable, agentic apps may make it operable.
This talk explores the emerging shift from user-driven applications to agent-operated systems, and what it means for how we design software.
We begin by examining a fundamental mismatch: modern web applications are built around human interaction models—navigation, clicks, and visual feedback—while AI agents operate through structured reasoning and action execution. This mismatch leads to brittle integrations, where agents rely on scraping, heuristics, or prompt-based inference to interact with systems never designed for them.
From this problem, we introduce the concept of agentic applications.
An agentic app is not defined by its interface, but by the capabilities it exposes. These capabilities represent the true functionality of the system—creating, updating, querying, or triggering workflows—and can be composed, orchestrated, and executed by agents.
We then connect this model to the broader ecosystem through the Model Context Protocol (MCP), which provides a standard interface for AI systems to interact with tools and services. MCP enables composability across systems, but primarily focuses on backend integrations.
This leaves an important gap: the frontend.
Modern frontend applications contain rich business logic, state transitions, and workflows that are invisible to agents. We explore how this layer can be made accessible through a new approach: WebMCP, which treats the browser as an execution environment and exposes frontend logic as structured, agent-consumable capabilities.
Using real world examples within React-based apps, we demonstrate how:
-UI components can be mapped to capabilities
-application state can be safely exposed and manipulated
-actions can be modeled as tools with clear contracts
-existing apps can be incrementally adapted without full rewrites
We also discuss architectural implications:
separating capability layers from presentation layers
designing for safety, permissions, and observability
enabling composability across multiple agent-driven systems
Finally, we explore open questions for the ecosystem:
What standards should define agent-facing interfaces?
How do we version and secure capabilities?
What replaces traditional API paradigms in agent-first systems?
This talk is aimed at developers and system designers interested in building the next generation of applications—where agents are not an afterthought, but a first-class part of the system.
But today, a new class of users has emerged: AI agents.
These agents don’t browse your application- they operate it. And the web, as it exists today, was never designed for this.
The result is a growing layer of fragile workarounds: DOM scraping, screenshot-based reasoning, and prompt-engineered workflows that attempt to “guess” what an application can do. These approaches treat interfaces as something to reverse-engineer, rather than something to integrate with.
In this talk, we introduce a new paradigm: agentic applications.
Agentic apps are not defined by their UI, but by the capabilities they expose. Instead of forcing agents to navigate interfaces, we give them structured access to the underlying actions, state, and logic of an application.
We’ll explore how this shift is already happening through emerging standards like the Model Context Protocol (MCP), which defines how AI systems interact with tools and services. While MCP addresses backend integration, it leaves a critical gap at the frontend-where most application logic still lives.
To bridge this, we’ll present WebMCP, an approach to turning web applications into programmable systems. Using real examples from React apps, we’ll show how existing UI logic can be exposed as structured, composable capabilities-allowing agents to interact with your app directly, without brittle selectors or reverse engineering.
We’ll cover practical patterns for designing agent-friendly systems:
-modeling capabilities instead of screens
-exposing safe, composable actions
-separating execution logic from presentation
-enabling agents to operate your app reliably
This is not just about AI tooling. It’s a shift in how we design software:
From user interfaces → to execution surfaces
From applications → to capability systems
From human-first → to multi-agent environments
If HTTP made the web readable, agentic apps may make it operable.
This talk explores the emerging shift from user-driven applications to agent-operated systems, and what it means for how we design software.
We begin by examining a fundamental mismatch: modern web applications are built around human interaction models—navigation, clicks, and visual feedback—while AI agents operate through structured reasoning and action execution. This mismatch leads to brittle integrations, where agents rely on scraping, heuristics, or prompt-based inference to interact with systems never designed for them.
From this problem, we introduce the concept of agentic applications.
An agentic app is not defined by its interface, but by the capabilities it exposes. These capabilities represent the true functionality of the system—creating, updating, querying, or triggering workflows—and can be composed, orchestrated, and executed by agents.
We then connect this model to the broader ecosystem through the Model Context Protocol (MCP), which provides a standard interface for AI systems to interact with tools and services. MCP enables composability across systems, but primarily focuses on backend integrations.
This leaves an important gap: the frontend.
Modern frontend applications contain rich business logic, state transitions, and workflows that are invisible to agents. We explore how this layer can be made accessible through a new approach: WebMCP, which treats the browser as an execution environment and exposes frontend logic as structured, agent-consumable capabilities.
Using real world examples within React-based apps, we demonstrate how:
-UI components can be mapped to capabilities
-application state can be safely exposed and manipulated
-actions can be modeled as tools with clear contracts
-existing apps can be incrementally adapted without full rewrites
We also discuss architectural implications:
separating capability layers from presentation layers
designing for safety, permissions, and observability
enabling composability across multiple agent-driven systems
Finally, we explore open questions for the ecosystem:
What standards should define agent-facing interfaces?
How do we version and secure capabilities?
What replaces traditional API paradigms in agent-first systems?
This talk is aimed at developers and system designers interested in building the next generation of applications—where agents are not an afterthought, but a first-class part of the system.
