The software was designed for humans. The user is now a machine.
The shift (arXiv:2603.20300): software historically optimized for graphical interfaces, usability, and cognitive alignment with human operators. LLM-based agents now invoke software autonomously through structured interfaces. The design philosophy must change.
Agent interfaces differ from human interfaces on every axis. Human interfaces are visual (buttons, menus, forms). Agent interfaces are structural (APIs, schemas, capability descriptions). Human interfaces tolerate ambiguity (a vague label is fine if the user recognizes it). Agent interfaces require machine interpretability (the agent needs to parse the capability's semantics). Human interfaces are navigated (you browse until you find what you need). Agent interfaces are invoked (the agent selects and calls capabilities based on structured descriptions).
The proposed architecture: capabilities as the unit of composition, not applications. Instead of monolithic apps with human-facing UIs, systems expose invocable capabilities — discrete, composable functions that AI agents dynamically assemble into workflows. The design principles: machine interpretability (structured descriptions the agent can reason about), composability (capabilities chain without human glue code), and invocation reliability (the capability either works or fails cleanly — no “half-completed dialog box” states).
The structural insight: the transition from human interfaces to agent interfaces isn't about adding an API layer to existing software. It's about redesigning from the capability outward. A human-designed application bundles capabilities into workflows the designer anticipated. An agent-designed system exposes capabilities as independent units, letting the agent compose workflows the designer never imagined. The unit of design shifts from the application to the capability.