← Back to the blog

November 14, 2026

Ten tools, one URL: shipping a remote MCP server

What it takes to put a whole product behind an MCP endpoint, and the three places the obvious choice is wrong.

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:

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.

Read next