Paper deep dive
From Human Interfaces to Agent Interfaces: Rethinking Software Design in the Age of AI-Native Systems
Shaolin Wang, Yi Mei, Haoyang Che, He Jiang, Shui Yu, Ying Gu
Intelligence
Status: succeeded | Model: anthropic/claude-sonnet-4.6 | Prompt: intel-v1 | Confidence: 97%
Last extracted: 3/24/2026, 2:10:51 AM
Summary
This paper argues that software engineering is undergoing a paradigm shift from human-oriented interfaces (GUIs) to agent-oriented invocation systems as LLM-based AI agents become primary software consumers. The authors formalize 'agent interfaces' and introduce 'invocable capabilities' as the fundamental abstraction for AI-oriented software, proposing design principles including machine interpretability, composability, explicit interface contracts, invocation reliability, and context compatibility. They discuss architectural implications including a transition from monolithic applications to capability-based systems dynamically composed by AI agents.
Entities (27)
Relation Signals (19)
Shaolin Wang → affiliatedwith → Geely Holding Group
confidence 99% · ∗ Geely Holding Group, China Email: {shaolin.wang1, Shui.Yu, ying.gu1}@zeekrlife.com
Shui Yu → affiliatedwith → Geely Holding Group
confidence 99% · ∗ Geely Holding Group, China Email: {shaolin.wang1, Shui.Yu, ying.gu1}@zeekrlife.com
Ying Gu → affiliatedwith → Geely Holding Group
confidence 99% · ∗ Geely Holding Group, China Email: {shaolin.wang1, Shui.Yu, ying.gu1}@zeekrlife.com
Yi Mei → affiliatedwith → Victoria University of Wellington
confidence 99% · † Victoria University of Wellington, New Zealand Email: yi.mei@ecs.vuw.ac.nz
He Jiang → affiliatedwith → Dalian University of Technology
confidence 99% · § Dalian University of Technology, China Email: jianghe@dlut.edu.cn
Invocable Capability → isfundamentalunitof → Agent Interface
confidence 98% · introduce invocable capabilities as the fundamental building blocks of AI-oriented software
Agent Interface → characterizedby → Machine Interpretability
confidence 97% · an agent interface is optimized for interpretability, reliable invocation, and composability
Agent Interface → characterizedby → Invocation Reliability
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Software systems have traditionally been designed for human interaction, emphasizing graphical user interfaces, usability, and cognitive alignment with end users. However, recent advances in large language model (LLM)-based agents are changing the primary consumers of software systems. Increasingly, software is no longer only used by humans, but also invoked autonomously by AI agents through structured interfaces. In this paper, we argue that software engineering is undergoing a paradigm shift from human-oriented interfaces to agent-oriented invocation systems. We formalize the notion of agent interfaces, introduce invocable capabilities as the fundamental building blocks of AI-oriented software, and outline design principles for such systems, including machine interpretability, composability, and invocation reliability. We then discuss architectural and organizational implications of this shift, highlighting a transition from monolithic applications to capability-based systems that can be dynamically composed by AI agents. The paper aims to provide a conceptual foundation for the emerging paradigm of AI-native software design.
Tags
Links
- Source: https://arxiv.org/abs/2603.20300v1
- Canonical: https://arxiv.org/abs/2603.20300v1
Trouble viewing inline? Open PDF directly →
Full Text
18,354 characters extracted from source content.
Expand or collapse full text
From Human Interfaces to Agent Interfaces: Rethinking Software Design in the Age of AI-Native Systems Shaolin Wang ∗ , Yi Mei † , Haoyang Che ‡ , He Jiang § , Shui Yu ∗ , Ying Gu ∗ ∗ Geely Holding Group, China Email: shaolin.wang1, Shui.Yu, ying.gu1@zeekrlife.com † Victoria University of Wellington, New Zealand Email: yi.mei@ecs.vuw.ac.nz ‡ Independent Researcher Email: bigdatache@q.com § Dalian University of Technology, China Email: jianghe@dlut.edu.cn Abstract—Software systems have traditionally been designed for human interaction, emphasizing graphical user interfaces, usability, and cognitive alignment with end users. However, recent advances in large language model (LLM)-based agents are changing the primary consumers of software systems. Increasingly, software is no longer only used by humans, but also invoked autonomously by AI agents through structured in- terfaces. In this paper, we argue that software engi- neering is undergoing a paradigm shift from human- oriented interfaces to agent-oriented invocation systems. We formalize the notion of agent interfaces, introduce invocable capabilities as the fundamental building blocks of AI-oriented software, and outline design principles for such systems, including machine interpretability, composability, and invocation reliability. We then dis- cuss architectural and organizational implications of this shift, highlighting a transition from monolithic applications to capability-based systems that can be dynamically composed by AI agents. The paper aims to provide a conceptual foundation for the emerging paradigm of AI-native software design. Index Terms—AI-native software, agent interfaces, invocable capabilities, software architecture, human-AI systems I. Introduction Software systems have historically been designed with humans as their primary users. Interfaces are optimized for visual perception, usability, and interaction efficiency, typically through graphical user interfaces (GUIs). In such systems, humans interpret information, make decisions, and execute actions through predefined workflows. This assumption is increasingly being challenged. The emergence of large language models (LLMs) and au- tonomous agents enables machines to interact with soft- ware systems directly. These agents can interpret natural language goals, plan multi-step tasks, invoke tools, and coordinate execution without continuous human interven- tion. As a result, software is no longer exclusively con- sumed through human-facing interfaces, but also through machine-driven interactions. This transition introduces a fundamental mismatch. Existing systems are largely optimized for human inter- action, making them difficult for AI agents to interpret, invoke, and compose reliably. Interfaces designed for hu- man cognition often lack the structure, determinism, and explicit semantics required for machine usage. Recent work on tool-using language models, agent-computer interfaces, and agentic software engineering collectively points to a deeper shift in the role of software itself [1], [2], [3]. In this paper, we argue that software design is undergo- ing a paradigm shift from human-oriented interfaces to agent-oriented invocation systems. Rather than treating AI as merely an assistant for writing software, we focus on a different question: how should software be designed when AI agents become first-class users of the system? To answer this question, we define the notion of an agent interface, introduce invocable capabilities as the funda- mental abstraction of AI-oriented software, and propose a set of design principles for systems optimized for machine invocation. The contributions of this paper are threefold: • We formalize the transition from human interfaces to agent interfaces as a software engineering paradigm shift. • We introduce invocable capability as the minimal ab- straction for AI-oriented software functionality. • We articulate design principles and architectural impli- cations for capability-oriented software systems. I. Related Work Our argument is related to several active research di- rections on tool use, coding agents, and human–AI in- teraction, but it differs from them in its primary unit of analysis. Existing work mainly studies how AI systems can arXiv:2603.20300v1 [cs.SE] 19 Mar 2026 better use tools, operate computers, or assist software de- velopment. In contrast, we focus on how software systems themselves should be designed when AI agents become first-class users. A. Tool Use and Function Invocation in LLMs A foundational line of work studies how language models invoke external tools. Toolformer showed that language models can learn when to call tools, which tools to call, and what arguments to pass, using APIs such as calculators, search engines, and calendars [1]. This line of research es- tablishes that software tools can become part of a model’s reasoning process. However, these approaches primarily treat tools as aug- mentations to model capability. They assume that callable tools already exist and focus on improving how models use them. In contrast, our work asks a complementary ques- tion: how should software systems themselves be designed to support reliable and scalable machine invocation? B. Agentic Programming and Software Engineering Agents A second line of work investigates autonomous agents for software engineering. SWE-agent demonstrates that carefully designed agent-computer interfaces (ACI) signif- icantly improve an agent’s ability to navigate repositories, edit code, and execute tests [2]. More recent work frames this trend as agentic programming or agentic software engineering, emphasizing planning, tool integration, and execution monitoring in coding agents [4], [5]. These approaches share a common assumption: software systems are primarily designed for human interaction, and agents must be adapted to operate within them. In this sense, they focus on adapting agents to existing software environments. In contrast, we argue for a complementary but funda- mentally different direction. Rather than adapting agents to human-oriented systems, we propose that software systems themselves should be redesigned to natively sup- port machine invocation. Under this view, agent-computer interfaces can be interpreted as transitional mechanisms that expose the mismatch between human-centric design and agent-centric usage. C. Human–AI Interface and Collaboration Design Another related stream studies interfaces for human– AI collaboration. Prior work emphasizes properties such as transparency, controllability, and representational com- patibility between humans and AI agents [6]. While this literature provides valuable insights into interaction design, it typically assumes that human in- teraction remains central. Our work considers a broader shift: when AI agents become primary users, the role of interfaces changes fundamentally, and software systems must be structured around machine invocation rather than human navigation. D. Intent-Centric and AI-Assisted Development Recent work on intent-centric development and "vibe coding" suggests that developers increasingly specify goals, curate context, and validate outcomes instead of directly implementing all logic [7]. This reflects a shift in how software is created. Our contribution complements this perspective by shift- ing attention from software creation to software structure and consumption. We argue that when AI agents become first-class users, the fundamental unit of software shifts from user-facing features to agent-invocable capabilities. E. Summary Overall, prior work demonstrates that AI systems can use tools, interact with computers, and participate in soft- ware engineering workflows [1], [2], [4], [5], [7]. However, these approaches largely operate within the constraints of software designed for human users. We argue that this perspective is incomplete. The emer- gence of AI agents as primary users calls for a rethinking of software design itself. We position agent interfaces and in- vocable capabilities as abstractions for this new paradigm, shifting the focus from adapting agents to systems toward designing systems for agents. I. Background and Motivation A. Human-Oriented Software Systems Traditional software systems are designed around hu- man interaction. Core design considerations include us- ability, visual clarity, and cognitive load. Interfaces such as web applications, mobile apps, and desktop GUIs en- able users to navigate features, input data, and trigger actions. In this paradigm, interaction is perception-driven, functionality is organized into features and pages, and execution is human-initiated. B. Rise of AI Agents as Software Users Recent advances in LLMs enable agents to understand goals, reason over context, and autonomously invoke ex- ternal tools. This capability is no longer limited to code generation or question answering. Agents increasingly operate over productivity applications, developer tools, search systems, and enterprise services. In effect, the “user” of software can now be an AI process that does not read screens the way humans do, but instead depends on structured interfaces, explicit contracts, and reliable side effects. C. The Core Mismatch Most contemporary software remains poorly suited for this mode of usage. Interfaces are often ambiguous, func- tional boundaries are coarse-grained, and execution se- mantics are hidden behind UI state or undocumented assumptions. These properties are tolerable for humans, who can infer missing context and recover from ambiguity, but they become major failure modes for autonomous agents. Human Interface EraAPI-Centric Transition Agent Interface Era Human user GUI / pages / forms Application logic Primary optimization: usability Unit of design: feature / page Execution mode: manual workflow Program / integration APIs and services Application logic Primary optimization: interoperability Unit of design: endpoint / service Execution mode: scripted integration AI agent Agent interface Capability A Capability B Capability C Data and services interface abstraction capability decomposition Fig. 1. Evolution of software interaction paradigms. The proposed shift is not merely from GUI to API, but from feature-centric applications consumed by humans to capability-oriented systems invoked and dynamically composed by AI agents. IV. From Human Interfaces to Agent Interfaces We define an agent interface as a software interaction layer designed for machine invocation, characterized by structured inputs, explicit semantics, and deterministic ex- ecution. Unlike a human interface, which is optimized for navigation and usability, an agent interface is optimized for interpretability, reliable invocation, and composability. Figure 1 summarizes the proposed paradigm shift. Human-oriented systems typically expose functionality through pages, forms, and workflows. API-centric sys- tems partially decouple functionality from the UI, but still often reflect service boundaries chosen for human- led integration. Agent-oriented systems go further: they expose software as a collection of invocable capabilities that can be selected and composed dynamically by an AI agent. Table I compares the two paradigms. TABLE I Human interfaces versus agent interfaces DimensionHuman InterfaceAgent Interface Interaction mode GUI-based navigation API / tool invoca- tion Input styleAmbiguous, flexible Structured, validated ExecutionManualAutonomous Optimization target UsabilityReliability CompositionPredefined workflow Dynamic orchestra- tion Primary abstrac- tion Feature / pageCapability/ contract The shift can therefore be stated more precisely: soft- ware is moving from perception-driven interaction to invocation-driven execution. This is not only an interface change, but also a change in software architecture, modu- larization strategy, and evaluation criteria. V. Invocable Capabilities as Fundamental Units To make agent interfaces concrete, we introduce the concept of an invocable capability. Definition. An invocable capability is a minimal, self- contained unit of functionality that exposes a structured interface and can be reliably executed by an AI agent without human intervention. This abstraction differs from a user-facing feature in several important ways. First, the input and output of an invocable capabi- lity must be explicitly structured. A capability should not rely on hidden UI state, informal conventions, or tacit assumptions. Second, the capability should be self- contained: it can be executed independently once its inputs are provided. Third, it should exhibit a high degree of predictability. Given the same inputs and environment, repeated invocations should produce behavior that is suf- ficiently consistent for planning and orchestration. These properties make invocable capabilities reusable across tasks and environments. Instead of binding software functionality to specific screens or rigid workflows, systems can expose fine-grained units that AI agents select and combine as needed. As such, the fundamental unit of software shifts from feature to capability. VI. Design Principles for AI-Oriented Software The proposed paradigm suggests several design princi- ples for software intended to support AI agents as first- class users. A. Machine Interpretability Software should expose functionality in a form that agents can reliably interpret. This includes explicit op- eration names, typed parameters, semantic descriptions, and clear state transitions. Ambiguity that is tolerable in human interfaces often becomes a source of failure for autonomous agents. B. Composable Capability Design Systems should prefer modular, reusable capabilities over coarse-grained features. A composable capability can be combined with other capabilities to support flexible problem solving. This is essential when agents dynamically plan execution paths rather than follow a fixed navigation flow. C. Explicit Interface Contracts All interactions should be governed by explicit con- tracts. Contracts specify input schemas, output schemas, constraints, validation rules, side effects, and failure modes. For human users, many of these details can remain implicit; for agents, they should be part of the interface definition. D. Invocation Reliability Autonomous invocation requires predictable and robust behavior. A capability should minimize hidden dependen- cies, provide transparent error handling, and support safe retries whenever possible. Reliability therefore becomes a first-class design objective, not merely an implementation quality attribute. E. Context Compatibility Because many AI agents operate within limited context windows, interfaces should be concise and semantically economical. Capability descriptions should be sufficiently rich to support correct use while remaining compact enough for efficient inclusion in agent context. VII. Discussion and Future Directions The proposed perspective has several implications for software engineering practice. A. From Monolithic Applications to Capability-Based Sys- tems We envision a future in which software is no longer organized primarily as monolithic applications with lay- ered human workflows. Instead, systems will increasingly expose collections of atomic, invocable capabilities that AI agents can discover, select, and combine at runtime. UI layers may remain important, but they will often become secondary interfaces for supervision, debugging, and exception handling. B. Changes in Architecture and Product Form This transition encourages a move from feature-centric product design to capability-centric platform design. In such systems, value is not determined solely by what a human can click through, but also by what an agent can reliably invoke. Discoverability, orchestration, capability granularity, and interface standardization become central architectural concerns. C. Open Challenges Several challenges remain open. First, capability granu- larity is non-trivial: overly coarse capabilities limit flexibil- ity, while overly fine capabilities may create planning over- head. Second, standardization of agent interfaces remains immature. Third, autonomous invocation introduces new concerns related to security, misuse, and policy enforce- ment. Finally, many real systems must serve both human and AI users, creating a need for dual-audience design rather than a complete replacement of one interface type with another. VIII. Conclusion The emergence of AI agents as active software users introduces a fundamental shift in software engineering. Systems are no longer designed solely for human interac- tion, but increasingly for machine invocation. In response, we argued for a transition from human interfaces to agent interfaces, introduced invocable capabilities as the funda- mental abstraction for AI-oriented software, and outlined design principles and architectural implications for this emerging paradigm. Our claim is not that graphical interfaces will disappear, nor that APIs alone solve the problem. Rather, the key shift is that software must increasingly be structured so that autonomous agents can understand, invoke, and compose functionality reliably. We believe this change will redefine how software is designed, modularized, and evaluated, marking an important step toward AI-native software systems. References [1] T. Schick et al., “Toolformer: Language models can teach them- selves to use tools,” arXiv preprint arXiv:2302.04761, 2023. [2] J. Yang et al., “Swe-agent: Agent-computer interfaces enable au- tomated software engineering,” arXiv preprint arXiv:2405.15793, 2024. [3] A. E. Hassan et al., “Agentic software engineering: Foun- dational pillars and a research roadmap,” arXiv preprint arXiv:2509.06216, 2025. [4] H. Wang et al., “Ai agentic programming: A survey of techniques and applications,” arXiv preprint arXiv:2508.11126, 2025. [5] A. Roychoudhury, “Agentic ai for software: Thoughts from pro- gramming language and software engineering research,” arXiv preprint arXiv:2508.17343, 2025. [6] A. De Masi et al., “Design properties for human-ai agent collab- oration,” arXiv preprint arXiv:2603.10664, 2026. [7] Y. Ge et al., “A survey of vibe coding with large language models,” arXiv preprint arXiv:2510.12399, 2025.