The interface after the screen: intent, state and trust

Traditional graphical software assumes that the user translates a goal into a sequence of interface operations. Agent-mediated software reverses part of that burden: the user describes an outcome, the system interprets the request, selects capabilities and returns either a result or an interface for the next decision.

This does not eliminate interaction design. It moves the design target upward. The critical questions become how intent is interpreted, when ambiguity triggers a question, which actions may proceed automatically and where the system must return control to the person using it.

• Design the intent contract, not only the control surface
• Make ambiguity visible before execution
• Treat confirmation points as part of the workflow architecture

Terminal agents make the change unusually clear. A coding agent can read files, execute commands, run tests and prepare changes through a conversational exchange. Its quality is experienced through approval timing, progress reporting, interruption, recovery and the clarity of its final state—not through a conventional screen layout.

Text, conversation and command execution are still interface modalities. The important distinction is not GUI versus CLI; it is direct manipulation versus delegated execution. Designers who understand feedback, pacing, affordance, error recovery and trust have useful work to do on both sides.

Agent-generated interfaces are most credible when freedom is bounded. A system can select from known components, assemble a declarative structure that a trusted renderer interprets, or generate an open-ended surface. Those modes carry different consistency, accessibility and security costs.

The design problem is therefore not simply whether a model can generate HTML. It is how much authority the agent receives over structure, data, behaviour and presentation. Component catalogues, semantic names, validation rules and rendering constraints become part of the interaction system.

• Static composition: the agent selects approved components
• Declarative composition: the agent describes structure and the client governs rendering
• Open-ended generation: maximum flexibility with the highest governance burden

Dynamic views matter, but state matters more. Conventional products often expose state through navigation: a sequence of pages, forms and confirmation screens. Agent systems can keep the task state in a conversation, a workflow, tool results and persistent memory, then render only the view needed for the current decision.

This means agents are more likely to compress navigation than abolish screens. Professional workspaces, precision tools and high-information interfaces remain valuable because direct manipulation is still superior when users need spatial judgement, rapid comparison or exact control.

As systems act with greater autonomy, provenance, permissions, reversibility and auditability stop being secondary features. A user must be able to understand what the system is doing, what it used, what changed and what remains under human control.

Progress displays, source attribution, approval boundaries, cancellation, undo and recovery paths are not decorative explanations of an agent. They are operational controls. A good interface exposes enough of the system state to support judgement without turning every action into a stream of internal reasoning.

• Show actions and evidence, not hidden chain-of-thought
• Make destructive or high-impact actions explicitly reversible where possible
• Separate confidence, permission and completion state

The visible experience still depends on typography, hierarchy, motion, composition and accessibility. Underneath it, the available experience is increasingly determined by schemas, tool contracts, semantic entities, state transitions, retrieval, memory and protocol boundaries.

The machine layer does not replace craft. It constrains what can be safely generated and what the agent can understand or operate. Designing the relationship between these layers is more durable than designing a catalogue of isolated screens.

This note is an original synthesis of the user-supplied English translation of 大原かほ’s 26 March 2026 article, “CLI and GUI — The Beginning of the End of the ‘Screen Design’ Era”, together with the accompanying critique supplied in the same source material. The source presents A2UI, AG-UI, MCP and related agent-interface proposals as part of an emerging stack; this synthesis preserves the distinction between established interaction shifts and still-maturing protocol ecosystems.

The central conclusion is deliberately narrower than “the end of screen design”: screens remain important, but they are increasingly outputs inside systems of intent, state, capability and trust.