Should AI interfaces be built in layers that catch failures, or organized around what users need, like control and trust?

This explores the difference between treating AI interface design as a stack of layers and treating it as a list of UX concerns. No paper in the corpus compares the two directly. Read side by side, though, the papers show a real split. Layers are organized around *where things go wrong* in the flow of an interaction. Categories are organized around *what users care about* at any point in it.

The clearest layered model is How should AI interfaces handle the shift from doing to supervising?. It has three surfaces. An Intent surface handles the fact that people struggle to say what they want. An Orchestration surface keeps track of the context that would otherwise get lost while the AI works. A Direct-Manipulation surface lets people make precise fixes when the output is close but not right. Each layer exists because of a specific failure mode, so the layers follow the order of the interaction: say what you want, watch it happen, then correct it. The first layer is backed by Why can't users articulate what they want from AI?. That paper finds that intent doesn't arrive fully formed. It develops through dialogue, so a dedicated surface for shaping intent makes sense rather than a single prompt box.

The category approach looks different. What design areas matter most for computer use agent UX? sorts agent UX into four areas: user prompts, explainability, user control, and mental model. What UX principles do workplace users want in AI agents? ranks eight principles by what workplace users value most. These are checklists of qualities rather than stages. 'Control' or 'explainability' can matter at any moment, which makes categories good for auditing a design but weak at telling you where a feature belongs. How should generative UI be organized as a design space? takes a third route. Its dimensions (audience, constancy, control, timeframe) are axes you set when choosing a kind of system. They are neither stages nor concerns.

The practical difference shows up when designs get built. Do generative UI tools actually implement their stated design rationales? found that generative UI tools recognized only about half of the UX principles written into their prompts, and skipped roughly a quarter of their own stated design rationales. A list of qualities is easy to state and easy to drop, because it doesn't fix any feature in place. Layers carry more structure, because each layer is defined by a job it has to do. The same idea appears on the agent side. Can structured interfaces help language models control GUIs better? reports that splitting an agent's interface into separate planning and grounding parts beat end-to-end prediction. Separating functions into layers seems to help machines as well as people.

The point you might not expect: both approaches may be organizing the wrong thing. How does AI context differ from conventional software context? argues that what really shapes AI behavior is the shifting context behind the screen: the prompt, the history, retrieved data, and hidden state. That paper says this calls for 'context engineering' rather than interface design. Nielsen's Orchestration layer is the one place where the layered model touches this. Read that way, layers suit AI better than categories because one layer can be made responsible for managing context, while a category like 'context-awareness' only names it as something users want.