Building
A desk that starts knowing nothing
Most of what I built on Bubblio this year rested on one assumption: the site owner writes down what agents may do. A list of tools, an MCP server, a manifest. Last week I threw that assumption out. This post is about what replaced it, how it works, and why I think it is where this ends up.
Nobody writes the list
Almost every proposal for an agent-ready website starts with the owner declaring tools: an MCP server, WebMCP in the browser, a catalog under .well-known. A big platform can do that once for all its stores, and Shopify now does. Everyone else has to write the list, keep it in step with the site, and guess which parts agents actually need. In practice the list never gets written, and agents keep reading pages that were built for eyes.
The other answer comes from the agent side: projects that map a website from the outside and turn it into an API without the owner. It works, but the site has no say, no record of who acted, and no way to tell an agent acting for its own customer from a scraper.
Both miss something simple. The site already sees every request an agent makes and how it answered. It is the only party that holds both halves. The list does not need to be written. It can be read off the traffic, with the owner deciding what goes live.
One line
import { withBubblioDesk } from '@bubblio/door/desk'
export const middleware = withBubblioDesk()That is the whole integration in a Next.js app. It uses only web-standard requests and Web Crypto, so it is not tied to Next. On day one it knows nothing about the site.
What it watches, and what it keeps
The desk sorts visitors by User-Agent. People in browsers, search crawlers and uptime monitors are ignored; AI assistants and scripts are recorded. That label only sorts traffic. Nothing downstream treats it as proof of who is asking. For an agent request, the scrubbing happens inside the site before anything leaves:
- The method, the path with ids turned into :id, and the status the site answered with.
- The shape of the query and body: field names and types, not values. No cookies, no headers.
- For a JSON answer, field names only, so agents can later be told what an action returns.
- A request that carries a password teaches the desk nothing.
Code learns, the owner decides, the model only names
Learning is plain code, not a model. Requests that repeat become candidate actions. A read that the site itself offers, through a link or a search form on its own pages, can go live by itself if the owner picked autopilot. Anything that changes something waits for the owner's tap in the dashboard. A model has one job: writing the sentence that says what each action does. Wording six actions for the demo shop cost about two hundredths of a cent.
Agents teach the desk what people want. Never what an action does, or what is allowed.
That rule came out of the hardest question in this build: what can a stranger do to your site just by sending it traffic? A few things I got wrong first:
- A request with a password field used to block its whole route for two weeks. So anyone could switch off your product search by sending it a fake password. Now that one request is simply left out.
- Actions that kept failing switched themselves off. Made-up product ids get a 404, so a stranger could turn off a working route. Now only failures that no caller could have caused count.
- Field names in an answer can be echoes of the request. A name is shown to agents only after two separate senders were each given it, and never when the caller sent that word itself.
- A separate sender means a separate network address, and a forwarding header is believed only when the server really runs on the platform that writes it.
Acting as a person
Reads are the easy half. Adding to a cart or placing an order has to happen as someone. The usual answer is OAuth plumbing in every site. The desk does it with no code: the person opens a connect link on the site while signed in, and their login moves to a separate session that only the agent uses.
It moves rather than copies because many sign-in systems rotate a refresh token on every use and treat reuse as theft, so a shared session logs one side out. The saved session opens only with two secrets: one held by the site, one wrapped under the agent's own key. Bubblio keeps neither in a form it can use, and the agent never sees the cookies. It can only ask the site to run an action that is already live.
Spending asks every time. The person approves with a passkey made when they connected, and the total is read again right before the order runs. On the demo I approved $7.44, had the agent add three more pens, and the confirm was refused. Nothing ran.
Why I think it goes this way
Agents are already a second audience for the web, and for the long tail of sites the cost of serving them has to be close to zero. The only thing cheaper than writing a list of tools is not writing one. Sites change every week, and a learned map changes with them. And it leaves the site, not the agent vendor, deciding who acts and how.
The test I care about most: I gave a fresh agent one sentence, "go to demo.bubblio.dev, add 2 blue gel pens to my cart, then tell me what is in my cart", and played the person who connects. It found the desk on its own and finished in nine web requests, none of them failed.
What it can't do yet
- A site that answers only in HTML still gets actions, but agents are not told what they return.
- It has to run on the site's own server, so Webflow sites and Shopify-hosted stores are out for now. How it gets onto site builders is what I am working out next.
- It is in private beta, and I am testing it on my own projects first.
The demo shop is at demo.bubblio.dev, and the full setup is in the desk docs. Point an agent at the shop and see what it learns.