Agent Interfaces: Structured Machine Interaction

• Agent interfaces are software layers designed for machine invocation with structured inputs, explicit semantics, and deterministic execution.
• They formalize capability contracts using typed actions, state models, and standardized protocols to support reliable and dynamic agent interactions.
• Applications span web interfaces, command surfaces, and protocol stacks, enhancing inter-agent communication, observation, and human oversight.

Agent interfaces are software interaction layers designed for machine invocation, characterized by structured inputs, explicit semantics, and deterministic execution. In current research, the term encompasses far more than API surfaces: it includes action spaces, observation channels, capability schemas, protocol stacks, negotiation layers, and human oversight surfaces through which agents perceive environments, invoke software, interoperate with other agents, and remain governable by humans (Wang et al., 19 Mar 2026). Taken together, recent work argues that many failures of contemporary agents arise not only from model limitations, but from a mismatch between agent capabilities and interfaces optimized for human perception, manual control, or developer-oriented abstraction (Lù et al., 12 Jun 2025).

1. Conceptual shift from human interfaces to agent interfaces

A central theme across the literature is a transition from human-oriented interaction to agent-oriented invocation. Traditional software emphasizes graphical user interfaces, usability, and cognitive alignment with end users, whereas agent interfaces optimize for interpretability, reliability, and composability for AI agents. Within this framing, an invocable capability is defined as “a minimal, self-contained unit of functionality that exposes a structured interface and can be reliably executed by an AI agent without human intervention,” shifting the primary abstraction from feature or page to capability or contract (Wang et al., 19 Mar 2026).

This shift is visible at internet scale as well. The Agent Network Protocol white paper describes four core trends: agents replacing traditional software, universal agent interconnection, native protocol-based connections, and autonomous agent organization and collaboration. ANP positions itself as a communication protocol system for the “Agentic Web,” specifically targeting large-scale agent interconnection and collaboration rather than human-facing browsing or application use (Chang et al., 18 Jul 2025).

On the web, the same diagnosis appears in stronger form. The Agentic Web Interface proposal argues that existing browser UIs and APIs are both poorly matched to autonomous web agents. Screenshots omit non-visible elements, DOM trees can exceed 1M tokens and carry rendering-oriented noise, and APIs expose a narrow, developer-oriented action set while sometimes bypassing ordinary user guardrails. AWIs are therefore introduced as interfaces specifically designed for autonomous agents, with optimal representations, tailored action spaces, safety and access controls, and cross-site standardization. The paper is explicit that an AWI is not simply a new API or another communication protocol, but a stateful, semantically-rich standard for agent-web interaction (Lù et al., 12 Jun 2025).

A related but distinct line of work extends the critique beyond the web. “Software as Content” identifies three structural limitations of chat-based natural language interfaces for human-agent interaction: representation mismatch between structured data and linear text, high interaction entropy from unconstrained natural language input, and ephemeral interaction state. Its response is not to eliminate language, but to make dynamically generated and evolving applications the primary medium of interaction, so that the interface itself becomes persistent, stateful software rather than transient conversation (Xie et al., 22 Mar 2026).

2. Core design principles and formal interface contracts

Despite domain diversity, papers converge on a common set of interface properties. Agent interfaces are repeatedly described as requiring machine interpretability, explicit contracts, composability, and reliable invocation. In practical terms, this means explicit operation names, typed parameters, structured input and output schemas, transparent error handling, minimal hidden state, and granular capabilities that can be dynamically orchestrated by agents rather than embedded in monolithic workflows (Wang et al., 19 Mar 2026).

One of the clearest formalizations appears in CLI-Anything, which defines the agent-software interface as a harness contract

$H = (S, C, I, R, V, D)$

where $S$ is persistent state, $C$ is command vocabulary, $I$ is inspection interface, $R$ is rendering or export relation to the real backend, $V$ is verification, and $D$ is discoverability. The paper also states invariants for such interfaces: explicit, accessible state; typed, domain-meaningful actions; cheap, programmatic inspection; backend-generated artifact truth; machine-verifiable outputs; and agent-readable discovery and skill metadata. This contract makes explicit that an agent interface is not only an action vocabulary, but also a state model, an inspection surface, and a verification regime (Yang et al., 2 Jun 2026).

At the component level, CI4A formalizes a web component interface as the semantic triplet

$$\langle \mathcal{S}, \mathcal{T}, \mathcal{M} \rangle$$

where $\mathcal{S}$ is the Semantic State View, $\mathcal{T}$ the Executable Toolset, and $S$0 the Interaction Metadata. The key idea is that agents should perceive business semantics directly, act through component-native tool primitives, and receive explicit parameter schemas, ranges, and constraints rather than inferring these indirectly from rendered DOM or screenshots (Qiu et al., 21 Jan 2026).

For web-scale standards, AWI design is organized around six principles: Standardized, Human-centric, Safe, Optimal Representations, Efficient to Host, and Developer-friendly. These principles make clear that agent-native interfaces are not defined solely by efficiency. They must also preserve human agency, privacy, and deployability within existing website architectures (Lù et al., 12 Jun 2025).

A plausible synthesis is that recent work treats an agent interface as a multilayer contract: semantic observability, typed actability, verifiable execution, and discoverable capability description. This suggests that raw tool exposure, by itself, is increasingly viewed as insufficient.

3. Action interfaces: command surfaces, semantic tools, and runtime bindings

Action-interface design has been studied most directly in software engineering and computer-use agents. SWE-agent introduces a custom agent-computer interface tailored to LLMs rather than humans. Its command set includes file-viewing primitives such as open, goto, scroll_up, and scroll_down; editing primitives such as edit and create; search commands such as find_file, search_file, and search_dir; retained access to shell commands for execution; and a submit command. The interface also incorporates informative but concise feedback, lint-based guardrails that reject syntactically invalid edits, and a context manager that keeps only the last five observations in detail. Evaluated on SWE-bench and HumanEvalFix, SWE-agent reports pass@1 rates of 12.47% and 87.7%, respectively, substantially exceeding prior non-interactive baselines and a shell-only agent variant (Yang et al., 2024).

CLI-Anything generalizes the same lesson beyond code repositories. It argues that GUI-centric computer use is brittle because pixel-level interactions, timing dependencies, and coordinate-based actions break under interface changes and force agents into human perceptual bottlenecks. Its “harness lift methodology” proceeds through archaeology and backend discovery, command-contract definition, CLI harness construction, backend enforcement, explicit state exposure, validation by execution, publication of agent-readable metadata, and distribution through CLI-Hub. The realized ecosystem includes 65+ generated or curated harnesses, 18+ public CLIs, 30+ categories, 61 companion skills, and 5 preview-capable integrations; telemetry is reported as 87.8% agent-share usage (Yang et al., 2 Jun 2026).

CI4A applies the same agent-native logic to front-end components instead of whole applications. Implemented within Ant Design across 23 categories of commonly used UI components, it exposes semantic tool primitives through a global registry and pairs them with a hybrid agent whose action space updates according to page state. On a semantically-preserving WebArena refactor, the CI4A-based agent reaches an 86.3% task success rate and reduces average steps to 4.7 in its visual mode, while also reporting a 57.5% decrease in average steps relative to the baseline summary provided in the paper (Qiu et al., 21 Jan 2026).

On mobile systems, AppAgent v2 constructs a flexible action space that can reference UI elements by Android ID, numerically annotated labels, detected text, visual features, or screen coordinates. It operates in exploration and deployment phases, backed by a structured, dynamically updated knowledge base and retrieval-augmented generation. The reported results include 77.8% completion on DroidTask in deployment-only mode, 84.4% and 93.3% success on the AppAgent benchmark under agent-driven and manual exploration, and 100% success on Mobile-Eval with more than 90% average Process Score (Li et al., 2024).

At a lower systems layer, action interfaces also arise as runtime bridges between execution environments. In Ludii, Python agent programming is enabled through jpy and Py4J interfaces to a Java game system. The analysis shows that jpy is faster than Py4J, while both remain slower than a native Java Ludii agent, underscoring that cross-runtime interface design has direct implications for agent throughput and algorithmic viability (Neto et al., 2024).

4. Observation interfaces, alignment layers, and environment mediation

Recent work increasingly treats observation as an interface design problem in its own right. AOI makes this explicit by arguing that current computer-use agents couple observation to action: one screenshot every 3–5 seconds, no audio, and therefore blindness to dynamic visual changes and spoken content between action steps. AOI decouples continuous, adaptive observation from discrete actions through three gated components: inter-step keyframe capture, volume-gated audio transcription, and model-generated visual narration that persists as text. On DynaCU-Bench, the reported gains are +17 to +48 percentage points over screenshot baselines without retraining. The paper also reports that keyframe selection strategy largely does not matter, that the largest benefit comes from visual narration rather than raw keyframe images, and that the optimal component bundle is model-specific because keyframe images can actively regress performance on some models through image-token dilution (Li et al., 28 Jun 2026).

ALIGN addresses a different observation problem: misalignment between what the agent expects an action to do and what the environment actually does. It formalizes the environment as

$S$1

and defines the interface as

$S$2

where InferRules enriches initial environment information and WrapStep augments step-wise observations with success or failure reasons, hints, and actionable feedback. Implemented as a lightweight wrapper that does not modify agent logic or environment code, ALIGN reports consistent improvements across embodied tasks, web navigation, and tool use, including up to +57.46% absolute improvement in ALFWorld for Self-Consistency and a 65% mean reduction in consecutive invalid actions in ALFWorld (Liu et al., 27 May 2025).

In multi-agent reinforcement learning, the Arena toolkit provides an earlier but still instructive abstraction: the Interface as a modular layer for customizing observations, actions, and rewards, altering cooperative-competitive interaction structures, and supporting self-play or third-party agents. Arena’s interfaces can be stacked sequentially, combined in parallel, and embedded either on environments or on agents, effectively extending Gym-style wrappers to MARL settings (Wang et al., 2019).

These works collectively undermine a common misconception that agent interfaces are equivalent to tool menus or action vocabularies. Current evidence indicates that observation cadence, modality, explanation, and wrapper-based mediation can change performance as much as, or more than, the action surface itself.

5. Protocol stacks for inter-agent communication and orchestration

At network scale, agent interfaces become protocol stacks rather than local command sets.

Framework	Interface structure	Primary scope
ANP	Three layers: identity and encrypted communication; meta-protocol negotiation; application protocols	Identity authentication, dynamic negotiation, discovery interoperability
ACPs	ARP, ADP, AIP, ATP, with extended A3AP and AMP	Registration, discovery, interaction, tooling, trustable access, workflow construction
Agent-OSI	Six layers from connectivity to semantic interoperability and orchestration	Messaging, identity, settlement, provenance, orchestration
HAWK	Five layers and sixteen standardized interfaces	Workflow orchestration, scheduling, resource invocation, data synchronization

ANP is built around DID-based identity, cryptographic authentication, ECDHE-based end-to-end encryption, dynamic meta-protocol negotiation, and application-layer description and discovery. Its Agent Description Protocol publishes machine-readable capability cards in JSON-LD, cryptographically bound to an agent’s DID, while discovery supports both well-known locations and indexed search. ANP’s three-layer decomposition targets identity authentication, dynamic negotiation, and capability discovery interoperability as first-class interface problems (Chang et al., 18 Jul 2025).

ACPs broaden the scope from communication to collaboration. Their protocol suite comprises ARP for registration, ADP for discovery, AIP for multi-agent interaction, ATP for tool access, and the extended A3AP and AMP layers for authentication, authorization, accounting, and management. The architecture is explicitly modular and layered for the Internet of Agents, with a collaborative restaurant booking scenario used to demonstrate capability orchestration, group formation, task decomposition, and tool-mediated workflow construction (Liu et al., 18 May 2025).

Agent-OSI adds economic and provenance layers to the stack. Its six layers run from connectivity and secure transport, through A2A messaging, identity, settlement, verifiable execution, and semantic interoperability. A key design choice is treating HTTP 402 as an application-level payment challenge analogous to HTTP 401 for authentication, binding payment, request, and provenance artifacts across the execution pipeline. In the prototype, keeping negotiation and delivery off-chain while preserving verifiable settlement reduces on-chain session costs by approximately 51% relative to the reported Web3 baseline, with roughly 159k gas per session versus 326k gas (Xu et al., 14 Feb 2026).

HAWK approaches interface standardization from workflow orchestration rather than network transport. It defines five layers—User, Workflow, Operator, Agent, and Resource—connected by sixteen standardized interfaces that cover task parsing, planning, monitoring, optimization, security, agent lifecycle management, and resource access. In the CreAgentive prototype, the reported outcomes include 10-chapter stories in approximately 80 minutes, support for up to five concurrent storylines, approximately 40% qualitative reduction in invocation complexity, and over 92% module stability (Cheng et al., 5 Jul 2025).

Edge deployment exposes current limits of these protocol designs. The A2A edge case study identifies heterogeneity, scalability, dynamicity, and resource constraints as the main challenges of agentic AI at the edge. Using A2A as the representative protocol, it notes that agent cards, decentralized identification, flexible message exchange, and web-standards-based delivery support heterogeneity, but resource awareness remains weak, registry-based discovery can become bottlenecked, and HTTP/JSON-RPC/SSE are heavy for constrained environments (Duan et al., 17 Aug 2025).

Specialized trust domains further refine interface boundaries. For agent-blockchain interoperability, one survey proposes a five-part taxonomy ranging from read-only analytics to multi-agent workflows, and introduces two key abstractions: a Transaction Intent Schema for portable, declarative goal specification and a Policy Decision Record for signed, machine-verifiable policy evaluation tied to a canonicalized intent hash. This architecture explicitly separates planning, policy, and signing to reduce blast radius and improve auditability (Alqithami, 8 Jan 2026).

6. Human oversight, dynamic interaction layers, and governance

Although much of the literature focuses on machine-to-machine invocation, a parallel line of work studies the human-facing surfaces through which agent behavior is supervised, redirected, or rendered intelligible. In Software as Content, the interface state at interaction cycle $S$3 is formalized as

$S$4

where $S$5 is the current view, $S$6 the affordance set, and $S$7 the execution context, with transitions given by

$S$8

This formulation treats dynamically generated applications, not chat transcripts, as the persistent interaction layer through which humans iteratively guide agent behavior. The design principles include structured interaction first with natural language always available, evolving rather than regenerating interfaces, preserving human agency, and managing accumulated complexity (Xie et al., 22 Mar 2026).

Governance-oriented work treats such surfaces as regulatory instruments. An analysis of 22 agentic systems synthesizes six UI patterns with governance potential: visible thoughts, plans, and actions; mechanisms for control transfer; watch mode; customizable rule-based governance; inspectable and editable agent memory; and sandboxes with low-level environmental control. The policy recommendation is not that UI regulation replaces system-level or infrastructure-level safeguards, but that it creates enforceable transparency and behavioral requirements that propagate downward into system design (Feng et al., 30 Nov 2025).

Human oversight can also be conditioned on human cognitive state rather than only on agent state. In a proof-of-concept multi-agent robotic system, EEG-derived engagement is converted into an HTTP-based signaling mechanism that places a primary agent’s sensory inputs and audio outputs into a holding state during periods of high engagement and releases queued communication once cognitive load returns toward baseline. The reported deployment figures include 94.2% of routine agent messages held during high cognitive load, 5.8% interrupted due to transient state changes, an average holding duration of 42.6 seconds, and zero breach of holding during validated “plateau” cognitive states (Kosmyna et al., 11 Jun 2026).

A distinct but related concern is who can design these interfaces. AgentBuilder studies agent-experience prototyping and identifies five recurring activities: designing agent scope and boundaries, information display, and user interaction; then running the prototype and understanding runtime behavior. It derives six desired capabilities for prototyping systems, including no-code interfaces, explicit control over task scope and user knowledge, specification of UI in chat and environment, reusable interaction components, runtime control, and debugging support. The resulting design probe combines graphical workflows, prompt panels, live preview, execution control, and replay-based debugging to broaden participation beyond AI engineers (Liang et al., 6 Oct 2025).

Current research therefore treats agent interfaces as simultaneously technical, organizational, and regulatory artifacts. Open issues remain explicit in the literature: standardization of capability granularity, harmonizing systems that must serve both humans and agents, scalable and resource-aware discovery at the edge, lightweight transport beyond heavy web standards, stronger observability and policy enforcement, and model-specific interface selection rather than fixed bundles (Wang et al., 19 Mar 2026). A plausible implication is that the field is converging on a layered view in which action, observation, communication, and governance interfaces must be co-designed, because optimizing any one layer in isolation increasingly appears insufficient (Li et al., 28 Jun 2026).