I run Webas, a website builder. You describe a site, it gets written, it goes live on a domain. One person builds it.
A few months ago the interesting question stopped being how do I make the editor better and became why is there an editor at all. People who want a website increasingly already have an assistant open. They have described the site they want, in detail, to Claude or ChatGPT, before they ever land on a pricing page. Asking them to then go and learn a drag-and-drop canvas is asking them to do the work twice.
So I put the whole product behind an MCP endpoint. No package to install, no local process: a URL you paste into your assistant, and ten tools behind it.
This is what that actually involved. The parts worth writing down are not the JSON-RPC plumbing, which is well documented and genuinely pleasant. They are three places where the obvious thing is wrong.
What the ten tools are
The shape of a tool set tells you what you think your product is. Mine:
- list_sites — list your websites
- get_page — read a page's code
- update_page — replace a page's code
- create_page — add a page to a website
- create_site — create a website
- rename_site — rename a website
- publish_site — put a website online
- site_stats — read visit numbers
- list_images — list stored images
- add_image — store an image from a URL
Nothing clever. The test I used: could someone go from nothing to a published site, and then come back a week later and change it, without ever opening the application? If a step in that story has no tool, the connector is a demo.
site_stats is the one I nearly left out, and it turned out to matter most.
It is the only tool that gives the assistant a reason to start a conversation
rather than finish one. "Your contact page got 40 views and no form
submissions" is a sentence that leads somewhere.
Mistake one: I let the annotations default
MCP lets you annotate each tool with hints: readOnlyHint, destructiveHint,
idempotentHint, openWorldHint. I skipped them at first. They are optional,
they are hints, and the tools worked without them.
Then I read what the defaults are.
destructiveHint defaults to true. openWorldHint defaults to true.
Not false. True. The spec is being careful on your behalf: absent a claim, a tool that writes is assumed to be able to destroy things, and is assumed to reach out into the open internet. That is the right default for a protocol. It was a terrible description of my tools.
Nine of my ten tools are not destructive. create_page adds a page. It cannot
remove one. publish_site puts a site online and does the same thing if you
call it twice. rename_site changes a string. By saying nothing, I was telling
every client that all seven of my writing tools might wreck something, which is
exactly the signal a cautious client uses to decide whether to confirm with the
user first, or to avoid chaining your tool at all.
Here is what it looks like, for the one tool where the scary default is correct:
'name' => 'update_page',
'annotations' => [
'title' => "Replace a page's code",
'readOnlyHint' => false,
'destructiveHint' => true,
'idempotentHint' => false,
'openWorldHint' => false,
],
update_page replaces a page's code with new code. The old code is gone. That
is destructive and it should be flagged, loudly. Out of ten tools, exactly one
is. And exactly one, add_image, which fetches an image from a URL you give
it, is open-world, because it is the only one that touches a host I do not
control.
The lesson is not "fill in the annotations." It is that omitting a hint is not neutral. It is a claim, and it is the most pessimistic one available.
An independent directory later scored my tool definitions an A. That grade is almost entirely this.
Mistake two: route ordering, twice
My connection endpoint is /mcp/{token} — paste the link, you are connected.
Two different directories then asked me to publish ownership proof. One wanted
it at /.well-known/<file> on the domain. The other at
/mcp/.well-known/<file>, scoped to the endpoint rather than the domain.
Look at that second path next to the route above.
/mcp/{token}
/mcp/.well-known/glama.json
Registered in the wrong order, .well-known is captured as {token}. The MCP
handler receives .well-known as a connection credential, finds no such token,
and returns 401. The verifier asks "does this domain claim this
connector?", gets an authentication challenge, and concludes: no.
Nothing crashes. No error appears in any log that anyone reads. You just do not get verified, and the reason is a route declaration order forty lines apart.
The same class of bug had already cost me something worse. Laravel route parameters are positional, not matched by name, and a mismatch there meant that for a period, contact forms submitted from customers' own custom domains 404'd. Every message a visitor sent from one of those sites was lost. Silently.
Both bugs are now held by tests that assert the ordering, not just the behaviour, because the behaviour is correct right up until someone adds a route above it.
Mistake three: assuming a 401 looks broken
My endpoint uses OAuth. An anonymous initialize gets:
HTTP/2 401
www-authenticate: Bearer realm="Webas",
resource_metadata="https://webas.app/.well-known/oauth-protected-resource"
I spent a while worried about this. Directories test that your endpoint answers
an initialize handshake before they will list it. Mine answers with a refusal.
Was I about to be rejected everywhere for being, correctly, authenticated?
No, and the reason is worth internalising. A spec-compliant 401 is an
answer. The WWW-Authenticate header names the realm and points at the
protected-resource metadata; the discovery documents are public and return 200;
a client reading them knows exactly how to proceed. Health checkers read that
as a healthy endpoint, because it is one.
The failure mode they are actually screening for is different: a URL that times out, a 404, a handshake stuck behind a paywall, or a per-user endpoint that nobody but the owner can reach. "Requires sign-in" is not that.
The confirmation came from the directory's own badge, which reads: ownership verified, tool definitions rated A, endpoint responding at last check, 10 tools. A 401, read as responding.
Publishing: a reverse-DNS namespace and an Ed25519 key
Getting into the official MCP registry is not a form. You claim a reverse-DNS
namespace — webas.app becomes app.webas — and you prove you control the
domain with a key:
openssl genpkey -algorithm Ed25519 -out key.pem
PUBLIC_KEY="$(openssl pkey -in key.pem -pubout -outform DER | tail -c 32 | base64)"
echo "v=MCPv1; k=ed25519; p=${PUBLIC_KEY}" > mcp-registry-auth
That file goes at /.well-known/mcp-registry-auth. The registry fetches it at
publish time and checks it against your signature. It is strict in ways that
bite: a redirect fails, a body over 4 KB fails, it gives up after fifteen
seconds, and it sends its own Accept and User-Agent. A CDN rule or a bot
filter that treats an unfamiliar agent as a crawler will quietly break this.
Two things the documentation will not tell you.
On macOS, openssl is LibreSSL and cannot do this. Algorithm Ed25519 not found. You need OpenSSL 3 explicitly.
The documented environment variable did not work. The docs pass the key via
MCP_PRIVATE_KEY. Version 1.8.9 of the publisher ignores it and requires a
flag:
mcp-publisher login http -domain webas.app -private-key "$PRIVATE_KEY_HEX"
Following the documentation gets you Error: ed25519 private key (hex) is required, with a key sitting right there in the environment.
One last thing worth being clear about, because it is easy to oversell: the registry verifies that you control the domain. It does not verify that your server works. It says so plainly. A listing can be fully verified and point at a broken endpoint. Verification is a claim about identity, not quality.
Was it worth it
Honestly: ask me in six months. What I can say now is that the distribution model is different in kind from anything else available to a one-person product. I did not have to convince anyone to install something, or to learn an interface, or to leave the thing they were already using. The server sits at a URL, and the registries and directories that people consult when they want to connect something are the channel.
The engineering was two weeks. Most of it was not JSON-RPC. It was the annotations, the route ordering, and reading the verification requirements closely enough to notice which failures are silent.
Those are the ones that cost you.