Agents assemble experiences dynamically from modular components, tailored to context, task, and user. Agent-assembled design and the design system imperative..
| Dimension | Traditional UX | Agentic Experience Design (AXD) |
|---|---|---|
| Primary material | Attention and affordance | Trust and delegation |
| User state | Present, navigating | Absent, delegating |
| Design output | Screens and interfaces | Outcomes and constraints |
| Temporal model | Session-based | Relationship-based |
| Success metric | Task completion | Trust calibration |
Composable interfaces are modular, reconfigurable interaction surfaces that agents can assemble dynamically based on context, user needs, and task requirements. Rather than fixed screens designed by humans, composable interfaces allow AI agents to construct the optimal interface for each moment - combining data displays, action controls, and information panels as needed.
Composable interfaces shift UX design from designing fixed screens to designing components and assembly rules. The designer no longer controls what the user sees at any given moment - instead, they design the building blocks and the constraints that govern how an agent assembles them. This is a fundamental shift from layout design to system design.
In agentic commerce, the customer may be a machine, not a human. Composable interfaces allow systems to present machine-readable data structures to agent customers while simultaneously offering human-readable interfaces to human customers. This dual-mode capability is essential for businesses serving both human and machine customers.
Composable interfaces are modular, reconfigurable interaction surfaces that agents can assemble dynamically based on context, user needs, and task requirements. Rather than fixed screens designed by humans, composable interfaces allow AI agents to construct the optimal interface for each moment - combining data displays, action controls, and information panels as needed.
Composable interfaces shift UX design from designing fixed screens to designing components and assembly rules. The designer no longer controls what the user sees at any given moment - instead, they design the building blocks and the constraints that govern how an agent assembles them. This is a fundamental shift from layout design to system design.
The Observatory · Issue 009 · October 2026 Imagine a city that rebuilds itself every morning. Not the buildings - the streets. The pathways between buildings rearrange overnight based on where people actually walked the day before. The shops that were most visited move closer to the residential areas. The park expands on sunny days and contracts on rainy ones. The hospital is always exactly where you need it to be, because the city knows you have an appointment. This is not a fantasy. It is a description of what happens when autonomous agents assemble interfaces from composable components. The buildings - the functional modules - remain constant. But the arrangement, the pathways, the proximity, the emphasis - all of these are determined dynamically by an agent that understands the user's context, intent, and history. In screen-based design, the interface was fixed. The designer determined the layout, the navigation, the information hierarchy. Every user saw the same structure. Personalisation, where it existed, was cosmetic - a recommended product here, a greeting there. The architecture was immutable. A composable interface is an experience surface assembled from discrete, self-contained components that can be combined, rearranged, and contextualised by an autonomous agent. Each component is a complete unit of functionality - it has its own data, its own interaction logic, its own visual presentation. But it is designed to be combined with other components in configurations that the original designer may never have anticipated. The concept borrows from software engineering's composable architecture movement - the shift from monolithic applications to microservices, from tightly coupled systems to Three properties distinguish a composable interface from a traditional one: Each component is self-contained and independently deployable. A balance display component works whether it appears on a dashboard, in a notification, or embedded in a third-party ap