HubSpot CTO Dharmesh Shah just made a bold claim: every B2B software company should be building a “headless” version of their product --- one designed for AI agents, not humans.

But he immediately added a warning: headless doesn’t mean brainless.

The AUI Shift

AUI --- Agentic User Interface --- is the emerging design paradigm for software that needs to work with both humans and AI agents. It’s not about removing the UI. It’s about adding a second interface layer designed specifically for how agents interact with your product.

As Dharmesh put it: if all agents wanted to do was use products like humans do, we’d just use “computer use” (screen-scraping AI that clicks buttons). The fact that we need something better tells you everything about where software design is heading.

The real challenge isn’t exposing APIs. Every product already has APIs. The challenge is designing the ergonomics of how agents actually want to consume and act on your product.

Why “Just Add an MCP Server” Isn’t Enough

MCP (Model Context Protocol) has become the default way to connect AI agents to external tools. And it works. But Dharmesh’s point is subtle: wrapping your existing API endpoints in an MCP server and calling it done is the 2026 equivalent of making a “mobile website” by shrinking your desktop site to fit a phone screen.

Agents don’t think like humans. They don’t browse, scan, and click. They need:

Structured, semantic data --- not HTML pages or PDFs, but clean formats like Markdown and JSON that can be parsed and reasoned about
Discoverable capabilities --- agents need to understand what your product can do without reading documentation
Predictable behavior --- agents can’t handle ambiguous UI states, modal dialogs, or “are you sure?” confirmations
Composable operations --- the ability to chain actions together without human intervention

What Good AUI Design Looks Like

Google recently launched A2UI (Agent-to-User Interface), an open protocol that lets agents generate UI natively --- choosing the right interface for each conversation rather than forcing everything through text.

But you don’t need a new protocol to start thinking about AUI. Here are the principles that matter:

1. Structured Output First

The single most important AUI decision is your data format. If your product outputs HTML, PDFs, or proprietary formats, agents have to work much harder to extract meaning.

Markdown is becoming the default interchange format for the agentic era. It’s structured enough for agents to parse, human-readable enough for users to verify, and lightweight enough to fit in context windows.

This is why web content conversion to Markdown has exploded in 2026. When an agent needs to research a topic, it doesn’t want a rendered webpage --- it wants clean, structured text.

2. Semantic, Not Visual

Traditional UIs communicate through visual hierarchy: bold headings, colored buttons, spatial layout. Agents don’t see any of this. They need semantic signals:

Clear headings that describe content sections
Metadata that explains what each piece of data represents
Consistent structure across similar content types

3. Agent-Readable Knowledge Bases

One of the most practical AUI patterns is simply making your product’s data available as a searchable knowledge base that agents can query.

Instead of building a complex API for every possible agent workflow, expose your data as structured Markdown files with good metadata. Agents can search, filter, and read what they need.

This is the approach that MCP enables: rather than building agent-specific UIs for every use case, provide agents with read access to structured data and let them figure out how to use it.

4. Progressive Disclosure for Agents

Just like good human UIs don’t dump all information at once, good AUI design gives agents the ability to:

Get a summary first, then drill into details
Search by relevance rather than browsing everything
Request only the data they need for their current task

AUI in Practice: The Knowledge Capture Pattern

One of the most common AUI patterns emerging in 2026 is the knowledge capture pipeline:

Web content (designed for humans) gets converted to Markdown (readable by both humans and agents)
Markdown files are organized into knowledge bases with metadata
Agents access knowledge bases via MCP or similar protocols
Agents can search, read, and cross-reference content across knowledge bases

This pattern works because it doesn’t require rebuilding any product for agents. It adds an agentic layer on top of existing web content.

Save implements exactly this pattern. Any webpage --- designed for human eyeballs --- gets converted to clean, AI-native Markdown. Save Vault organizes it into knowledge bases. The built-in MCP server makes it all searchable by Claude.

The result: any information on the web becomes part of an agentic knowledge layer without the original website doing anything differently.

Two Levels of Agentic

Dharmesh made a distinction that’s worth remembering. He told HubSpot’s exec team:

Being agentic is not just about agents running on our platform, it’s about agents running our platform.

There are two levels:

Level 1: Agents on your platform --- AI features embedded in your product. Chatbots, auto-complete, AI-generated summaries. The product remains human-operated with AI assistance.

Level 2: Agents operating your platform --- AI agents that can autonomously use your product to accomplish goals. The product is agent-operated with human oversight.

Most products today are at Level 1. The AUI paradigm is about reaching Level 2 --- and it requires rethinking your product’s interface from the ground up.

What This Means for Users

You don’t have to wait for every product to build AUI support. You can create your own agentic layer today:

Convert web content to Markdown --- This transforms any human-designed website into agent-readable knowledge
Organize into knowledge bases --- Structure your saved content so agents can search it effectively
Connect via MCP --- Give your AI assistant direct access to your curated knowledge

This approach works with any product, any website, any content source. You’re essentially building a personal AUI layer that makes the entire web accessible to your AI tools.

The Future of Interfaces

The AUI shift isn’t about replacing human interfaces. It’s about recognizing that software now has two audiences: humans who click and agents who query.

The products that win in the agentic era will be the ones that thoughtfully design for both. And the users who thrive will be the ones who build their own agentic knowledge layer --- turning the messy, visual web into structured, searchable, agent-ready Markdown.

The interface paradigm is expanding. The question isn’t whether your tools need an agentic layer --- it’s how fast you build one.

Save converts any webpage into clean, agent-ready Markdown and stores it in your local knowledge base. Save Vault’s built-in MCP server makes your saved content searchable by Claude. Try Save for free.