Warren Husband

Chief Technology Officer at EdgeTheory

The Interface Is Optional Now

For most of the history of software, using a system meant opening it. You logged in, found the right screen, and clicked through the steps someone designed for you. That assumption is starting to break. More and more, people will just say what they want done and let an assistant go get it from whatever systems hold the answer.

A few weeks ago, an executive I work with spent a drive building out a stack of analysis by talking to his AI assistant on his phone. When he sat down at his desk, all of it was waiting for him in our product. He never opened the app.

I've been building software since 1995. For nearly all of that time, the user interface was the product. Now the screen is one way in among several, and sometimes it isn't the one people use most.

The technology making this possible is a fairly unglamorous standard called the Model Context Protocol, or MCP. At EdgeTheory, we used it twice this year: first inside the company, then for our customers. Here's what that taught me.

Plumbing, not magic

MCP gives an AI assistant a standard way to connect to a system's tools and data. A system publishes what it can do, and an assistant that speaks the protocol can use those capabilities without a custom integration for every pairing.

There's no intelligence in the protocol itself. The reasoning happens in whatever model you're already using. MCP is the plumbing that lets that model reach the places where your work actually lives.

MCP has spread fast. Anthropic introduced it in November 2024, and in December 2025 donated it to the Agentic AI Foundation, a new fund under the Linux Foundation co-founded by Anthropic, Block and OpenAI. By then there were more than 10,000 published MCP servers, and Claude, ChatGPT, Gemini, Microsoft Copilot, Cursor and VS Code had all adopted it. In August, Google's Agent2Agent protocol, which handles how agents talk to each other, joined the same foundation.

Companies that compete hard on models are now cooperating on the connections between them. That's usually the sign a technology has stopped being an experiment and started becoming infrastructure.

Not everyone is opening the door

In October, Walmart launched an Agent Gateway, an MCP server that lets approved AI agents search its inventory and make purchases for customers. Each agent gets its own profile. Customers can require approval for every purchase or set a spending limit, and agents never see payment information. Agents that break Walmart's published terms get blocked.

Around the same time, Amazon began blocking AI agents from making purchases for shoppers, including Meta's new Muse shopping agent.

Two of the largest retailers in the world made opposite bets. Retail just happens to be where it's most visible. Anyone who runs software people depend on is going to face the same question: when your customers' assistants show up, do you give them a governed way in, or try to keep them out?

At EdgeTheory, we decided to build the way in. People will use the assistant they like. But we built it for ourselves first.

Inside first: Vesper

In September, I started building Vesper, our internal knowledge layer.

Vesper has no AI of its own. It routes context. The reasoning happens in whatever assistant each person already uses, and the tokens are spent on their side. Nobody has to give up the tools they already like.

Notion and Jira remain our record of intent. Vesper is the live window into what the product and the data are actually doing. You can ask a question without knowing which system has the answer or which screen to open.

We opened it one slice of data at a time, with approval for each. Access follows who you are, and everything is audited. Some questions are off-limits for some roles. When that happens, Vesper says so plainly instead of letting the assistant guess around the gap. A clear "you don't have access to that" builds more trust than a confident wrong answer.

Every source we connect shows up for everyone who has access to it, in whatever assistant they use, so the whole thing gets more useful each time we add one. My rule of thumb for what belongs in it: the moment two people need to do the same thing, it goes in Vesper.

Outside: EdgeContext

In late October, we built the same pattern for customers with EdgeContext, which lets a customer's own AI assistant work with their EdgeTheory data. It's in pilot now.

You sign in with your existing product login, and the assistant can do no more than you can do in the app. It's a new way in, not a new set of powers. Your identity and permissions carry over to the assistant. There's no second login system and no special account with extra access.

We started read-only, and a security review was required before launch, not something we'd get to later. Vesper had shown us that assistants remember a system's tools from the moment they connect. So we kept the set of tools fixed and let their capabilities grow behind them. New abilities can reach users without requiring them to reconnect.

We learned a lot by watching colleagues outside engineering connect for the first time. Within a day, we'd added setup pages and better guidance inside the product. Nobody should have to understand the protocol to get connected. The setup and the documentation are part of the product now.

By early November, EdgeContext could change data, not just read it. That's a different conversation.

Reads are easy. Writes are where the risk lives.

Letting an assistant read and summarize is relatively low risk. If it gets something wrong, a person can catch it before anything happens.

Creating, editing, deleting, approving and buying are different. An agent can take those actions faster and more often than any person would. It can also encounter instructions hidden in the material it's asked to read. A document, message or web page may contain text intended to redirect the assistant away from the user's request. Once an agent can act, the content it reads becomes part of the attack surface.

In EdgeContext, reading and changing are separate tools, and the change tool is labeled so the assistant asks you before it uses it.

We also keep some things out of reach entirely: administrative tools and anything that changes permissions. Deletes and anything that sends something out sit behind the change tool, so the person is asked first. Exposing an API doesn't mean an agent should be allowed to use it.

When a person works through screens, the screens slow them down in useful ways. There's a moment to look, think and catch a mistake. An agent working through tools doesn't get those moments. So the safeguards have to be built into the system itself: permissions, approvals, audit trails and clear limits on what an agent can do.

Some say software matters less now that any assistant can use any system. I see it the other way. Someone still has to decide what an agent may touch, build the permissions and audit trails, write the documentation it depends on, and design the confirmations that keep a person in charge. That work is harder than building screens ever was, and it's where engineering judgment matters most.

Checking the work

In "Information Is Outrunning People," I wrote that information is being produced faster than anyone can read it. In "AI Is Starting to Build AI. Who's Checking the Work?," I argued that verification has to keep pace with generation.

Agents connected through standards like MCP take that one step further. They don't just produce information faster. They act faster.

When people no longer have to move through an interface, the checks that once happened as they clicked through screens have to happen elsewhere. That means permissions, approvals and a record of what the agent actually did. People need to be able to check the result, not just trust that the assistant got it right.

The interface may be optional now. Accountability isn't.


is CTO at EdgeTheory and has been building software since 1995. He lives in Mississippi. Views are my own and do not represent EdgeTheory.