An application can be easy for a person to navigate while remaining difficult for an AI agent to operate. Buttons, menus, and dashboards communicate through visual conventions. An agent needs a reliable way to identify capabilities, supply valid inputs, and understand whether an action succeeded.
That introduces another design concern: agentic experience, or AX.
GeekyAnts’ article on designing applications for AI agents, adapted from Ashita Prasad’s thegeekconf mini session, explores this shift. It identifies three approaches: exposing website capabilities through WebMCP, embedding interactive interfaces in AI clients through MCP Apps, and generating interfaces inside applications through A2UI.
The useful engineering question is where each approach belongs, and which companies provide relevant services or tooling.
What does AX add to application design?
The source article describes applications serving two audiences: people and agents. It also highlights accessibility as a useful starting point, since meaningful labels and interface semantics can help agents interpret controls.
However, making an interface understandable does not establish permission to use it.
A hypothetical scheduling application illustrates the distinction. An agent might discover an appointment tool and identify an available slot. The backend must still establish whether the current user can make that booking and whether the slot remains available.
AX should make application capabilities explicit while preserving the application’s rules.
Three approaches that solve different problems
| Approach | Where interaction happens | Main purpose |
|---|---|---|
| WebMCP | Within a website’s browser context | Expose page capabilities as structured tools |
| MCP Apps | Inside a supporting AI client | Present interactive application UI alongside a conversation |
| A2UI | Inside an application with a compatible renderer | Describe interfaces using structured, declarative messages |
WebMCP: Make website actions discoverable
WebMCP is a proposed web standard for exposing structured tools through JavaScript and annotated HTML forms. Chrome’s documentation describes it as a progressive enhancement and notes that it remains under active development. It should therefore be evaluated against actual browser support. WebMCP documentation
A useful design exercise is to identify one existing application capability, such as searching appointments, and define its inputs and possible results.
That exercise also exposes ambiguity. Does “book appointment” reserve a slot temporarily or confirm it immediately? An agent should not have to infer the difference from a button label.
MCP Apps: Bring useful controls into the conversation
MCP Apps extends MCP with interactive interfaces rendered inside supporting hosts. It connects tool results with UI resources, allowing experiences such as forms and dashboards within an AI client. MCP Apps documentation
This matters when a conversation reaches a point where direct manipulation is easier than another prompt. Selecting a date range or inspecting chart values can be more practical through controls.
Host compatibility remains part of the implementation. Teams should test the intended client and provide a useful fallback when interactive rendering is unavailable.
A2UI: Let agents describe interfaces within boundaries
A2UI uses declarative descriptions that a client renders through supported components. Its approach separates an agent’s description of an interface from the application’s rendering implementation. A2UI documentation
The architectural value is controlled flexibility. An application can support changing combinations of approved components while retaining responsibility for their behavior.
A generated confirmation button still needs an authorized backend operation. Valid UI output is only one layer of correctness.
Five companies relevant to this shift
This is an editorial shortlist based on published capabilities, not a measured performance ranking. It includes an engineering services company alongside platform and tooling providers.
1. GeekyAnts: Custom application integration
GeekyAnts describes services covering agent interaction design, enterprise integration, grounding, validation, and lifecycle monitoring. Those capabilities are relevant when agent functionality must become part of an existing product. AI agent development services
Its AX article provides a technical introduction, but publishing about a protocol does not establish production delivery experience with it.
For an engineering evaluation, the useful questions concern comparable implementations, accessible interfaces, backend authorization, and maintenance ownership.
2. Google: Browser capabilities and declarative interfaces
Google’s Chrome work on WebMCP and the Google-led A2UI project address different parts of agent interaction: exposing website capabilities and describing interfaces for application renderers. Chrome WebMCP, A2UI
These projects merit attention from developers exploring application architecture. Teams should assess implementation maturity and supported environments before depending on them for a critical workflow.
3. Anthropic: Interactive applications inside Claude
Anthropic supports interactive connectors through MCP Apps in Claude, allowing supported applications to present interfaces within conversations. Interactive tools in Claude
This provides a concrete distribution model for application functionality inside an AI client.
The evaluation should include authentication, host restrictions, and the behavior of users who still need the standalone application. An embedded experience should have a clear relationship with the product’s existing workflows.
4. Vercel: Building agent interactions in web applications
Vercel’s AI SDK provides TypeScript tooling for model interaction, structured output, tool calls, and agents. Its UI capabilities support chat and generative interfaces. AI SDK overview
This makes Vercel relevant to teams implementing agent experiences within their own web products.
The SDK supplies building blocks. Developers still need to define loading states, approval flows, error recovery, and how tool results map to interface components.
5. Microsoft: Agent workflows in business applications
Microsoft’s Copilot Studio provides an approach to designing autonomous agents within its business technology ecosystem. Autonomous agent guidance
Its relevance is strongest when the intended experience connects to established organizational workflows.
Teams should distinguish workflow automation from interface portability. A functioning agent in one environment does not establish that its interface or tools will operate unchanged in another host.
What should developers build first?
A bounded experiment can reveal more than a broad interface redesign:
- Select one task with a clear success condition.
- Define inputs, outputs, permissions, and failure states.
- Preserve a usable human interaction path.
- Test invalid inputs, expired sessions, and repeated actions.
- Measure completion, corrections, latency, and recovery.
For a scheduling prototype, success might mean that an authorized user confirms exactly one valid appointment, receives an identifiable result, and can recover from an interrupted request.
That definition is more useful than counting how many screens the agent bypassed.
AX makes another interaction path possible. The application still needs to deliver an understandable, authorized, and verifiable outcome.
Top comments (1)
Really interesting shift from UX to AX. I liked the GeekyAnts reference here, especially the point that making an interface understandable to an AI agent isn't enough the backend still needs proper permissions, validation, and safeguards. That distinction will become increasingly important as more applications start supporting agent-driven workflows.