Almost four years after large language models became popular, the default interface of an AI product is still a text box. You ask, the model writes back, and whatever you wanted to do next you type as another sentence.
That works for questions. It works badly for the things user interfaces were built for. Nobody designed the table, the seat map or the confirm button by accident. Each one does a job that words do slowly.
What text is bad at
Here is the reply a chat gives when you ask it to book a flight, and the same answer drawn as an interface.
Book me a flight to Lisbon on Friday.
Chat only
I found three flights to Lisbon on Friday. Option 1 is TAP, leaving at 07:10 and landing at 10:05, nonstop, 2 hours 55 minutes, for 184 euros. Option 2 is Iberia, leaving at 09:40 and landing at 14:15 with a stop in Madrid, 4 hours 35 minutes, for 139 euros. Option 3 is Lufthansa, leaving at 13:20 and landing at 18:40 with a stop in Frankfurt, 5 hours 20 minutes, for 162 euros. Reply with the number of the flight you want. Then tell me which seat you would like: in row 14, seats A, C, D and F are free, and so are B and E in row 15. After that, type yes to confirm the payment.
Chat with an interface
Seat 14C
Total€184
Three things went wrong in the text reply. Comparing three flights became a paragraph. Choosing a flight became typing a number, and choosing a seat became reading a list of letters. Confirming a payment became the word "yes", typed into the same chat the model reads and writes in.
The controls for these three jobs exist. A chat that can only write text cannot show them.
MCP Apps bring the interface back
MCP Apps is an extension of the Model Context Protocol that lets a tool answer with an interface as well as text. The server ships a small HTML page as a resource. When a tool result points at it, the host draws the page in a sandboxed frame inside the conversation and hands it the result's data. The page talks to the host over messages, and the host decides which tools it may call.
- The tool answers
The result carries text for the model and data for the interface.
- The host draws it
A page the server shipped, in a sandboxed frame inside the conversation.
- You press
The page asks the host to call a tool, or tells the chat what you chose.
The model still gets the text. The person gets something to look at and to press. In a host that draws no interfaces nothing breaks, because the same result reads as text.
What we built with it
Delegate is a marketplace where agents hire services. Buying there means comparing services, choosing one and confirming a price, the same three jobs as the flight, and afterwards rating what you got. We call our interfaces cards. These are the four your agent can show today in a host that draws MCP Apps:
- The catalog. Search, category chips, a sort and one row per service, laid out like the catalog on our site.
- The order card. When several services fit, it shows them side by side and you pick. When an order needs your approval, it shows the amount, the service, what is shared with the provider and your balance after.
- The rating card. Each run you bought with five stars under it. Picking a star saves.
- Rooms. The list of your rooms and, inside one, its goal and where the work stands.
Let the agent build the interface
Those four cards cover Delegate's own flows. Your task may need an interface nobody has built yet: a calculator for the contract you just uploaded, a sortable table of the 40 companies the agent found, a checklist for one trip.
For that there is UI Builder, a provider on Delegate with two services. Build an app takes a request in plain language, and optionally a source file (HTML, text, Markdown, or a PDF of up to 50 pages with selectable text), and delivers a small self-contained page. Show an HTML page as an app takes a page you already have and delivers it unchanged. A host that draws MCP Apps shows the page in the chat. In any other host you get it as a file.
UI Builder in the catalog
Delegate shows the app in a frame built to have no network access. The app cannot load anything from the internet, keep data between visits, open pop-ups or start downloads. The page may have been written by a model a minute ago, so the frame is where we draw the line, and the page's own code is not what we rely on.
The rules we kept
Putting buttons into a chat an AI model reads sharpens the question the typed "yes" already raised: who pressed it?
The model cannot approve. Where we can tell that the click came from you, which by default means a sign-in through Claude, Approve on the card places the order with a token that only the card is given. In every other host the card shows the same facts and sends you to Delegate to approve there. The model knows the order exists, but it never holds the token, so it cannot push through an order that waits for your approval by claiming you agreed.
Cards load nothing from the network. Fonts, logo and styles travel inside the page. No tracker, no request to a third party.
The card shrinks when it is done. Once you have chosen, the order card turns into a receipt of a single row.
Text still works. Every card's result also reads as plain text, and an approval comes with a link to approve in Delegate. Without cards you can still search, pick, approve and rate, through text and that link.
When text is still right
A question with one answer needs a sentence. So does an explanation, a summary or a draft. If the next step is reading, write text. If the next step is comparing, choosing or confirming, the chat should show the control that was built for that job.