A remote MCP server is a hosted HTTP endpoint your agent client reaches over the network instead of spawning on your own machine. We don't explain that from the outside looking in: ScriptMasterLabs runs a fleet of 24 remote MCP servers exposing 182 tools, and our gateway — OMNIGATE — is one of them, live and keyless today. This is the connection guide we would hand our own customers: what a remote MCP server is, the three calls every connection makes, the three ways a hosted server can ask you to prove yourself, and the exact configs that work against a real endpoint — ours.
What is a remote MCP server, and how does it differ from a local one?
Same protocol, different transport. A local stdio server is a process your client spawns and talks to over stdin/stdout; your client owns its lifecycle, its crashes, and its updates. A remote server lives at a single URL and speaks streamable HTTP: your client POSTs JSON-RPC messages to that endpoint and receives responses as a stream. The operator owns the lifecycle — you reconnect, but you never patch, restart, or reinstall anything.
Choose remote when the data lives at the provider, when you want zero local install, or when the server charges per call instead of asking for an account. Choose local when latency matters, when a tool needs filesystem access, or when a third party seeing your queries is a non-starter.
The three calls every connection makes
Every remote MCP connection follows the same contract, no matter which client you use:
- initialize — the client introduces itself and negotiates the protocol version.
- tools/list — the client asks what the server exposes.
- tools/call — the client invokes one tool per call.
This is not theory on our side. Connecting to OMNIGATE (https://mcp-x402.onrender.com/mcp) with a plain HTTP POST returns, on initialize, protocol version 2025-03-26 and server mcp-x402 v2.1.11 — and tools/list answers with 9 tools, no credential sent. Only the client config changes between tools; the three calls never do.
Three ways a remote server asks you to prove yourself
- A static credential in a header
The simplest hosted setup: an Authorization: Bearer token header (or a vendor header like X-API-Key) travels with every request. It works, but every call is trusted purely on that string — a leaked token is a leaked account, and rotation means editing config everywhere the token lives.
- OAuth 2.1 — authorize in the browser, get a scoped token
Servers acting on a user's behalf use the MCP authorization pattern: add the endpoint as a custom connector in your client, complete a browser authorization, select the account or organization the token should act for, and receive a scoped token your client reuses. We verified this pattern hands-on today while sizing up QuantConnect's new remote MCP (https://www.quantconnect.com/api/v2/mcp): standard MCP HTTP transport, an "Authorize MCP Server" form in the browser, organization selected at consent. The interesting gate wasn't technical at all — QuantConnect's own docs require a paid agent node on the account before the remote MCP will connect; their free node tier is refused. Expect that shape from mature providers: the protocol is open, the account tier is the toll.
- x402 — the 402 challenge replaces the credential entirely
Our fleet's model. OMNIGATE asks for no key and no account: its status reports "auth": "none", and its five read-only tools answer anyone — gateway status, the canonical payment contract, runtime catalog search with live per-call prices, receipts. The paid tools work the other way: call one unpaid and the server returns an HTTP 402 challenge naming the price, the payee, and the network. Your client's wallet pays in USDC, and the call retries with the payment proof attached. No registration, no token rotation, and the spend policy lives in the agent's wallet, not in a vendor dashboard.
The prices are printed in the tools themselves, so an agent can read them before it spends:
- Spend Gate (spend_gate_check) — $0.005 USDC on Base: an advisory pay/don't-pay assessment before an agent wallet pays someone.
- Coherent Gate (interfere) — $0.01 / $0.05 / $0.25 USDC by path count: scores whether independent signal paths actually agree, and gates on the agreement.
- Settlement runs in USDC on Base, with an Arc escrow rail on the gate tools — the fee is collected inside the settlement, so no credit is ever extended.
Compare that honestly with the alternatives: a keyed API trusts a string; an OAuth server trusts an account; an x402 server trusts a payment it can verify. For agents that manage real capital, the third model is the one where the budget is enforced at the request level — a runaway loop can spend only what the wallet policy allows.
Working configs
Claude Code, one line from your shell, pointed at our gateway:
claude mcp add --transport http omnigate https://mcp-x402.onrender.com/mcp
The JSON shape every other client (Cursor, Claude Desktop, custom agents) uses:
{
"mcpServers": {
"omnigate": {
"type": "http",
"url": "https://mcp-x402.onrender.com/mcp"
}
}
}
No headers block — there is no key to put in one. And if your client supports custom connectors with a connect flow, the same endpoint drops in there: OMNIGATE is connected inside Muse itself as a private custom connector, its five free tools live through that connection, while the four paid tools stay blocked on that route for an instructive reason — a chat connector can't settle a 402, so the paid surface belongs to clients that carry a wallet.
The local contrast, for the servers you do run yourself:
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]
}
}
}
A command, not a URL — that's the whole difference.
The rest of the fleet connects the same way
OMNIGATE is the front door, not the whole building. The same three calls reach the fleet behind it — including Verdict Protocol, our decision layer, at $0.25 USDC per decision (and $0.01 to seal the receipt), where a sealed decision capsule plus five specialized jurors score a proposed action before an agent commits funds. Every one of the 24 servers — 182 tools, each declared in code with its schema and its price in the description — carries a copy-paste install prompt at scriptmasterlabs.com/muse-connect, and the full catalog lives at scriptmasterlabs.com/sml-products.
Why directories show the wrong tools for your remote server
Because most of them never connect to it. Directories read static artifacts — your package metadata, your repo, your registry record — each a different source. A tool list that only exists at runtime is invisible to all of them, and a tools/list built from a live fetch can hang a directory's probe outright. The fix we ship across all 24 servers: bake the static tool list, endpoint, and prices into the published source, every release. It's why the catalog search on our own gateway and the install hub read the same 182 tools a connecting client finds. If your listing shows stale tools, don't debug the directory — check what your published source actually declares.
Common connection errors, quickly
- 404 on the endpoint — the URL is missing the path the server expects (/mcp or a version prefix). Read the server's llms.txt or contract before debugging your client.
- Auth failures — the credential went in the wrong header, or the server wanted OAuth and you pasted a token. And on an x402 server, a 402 is not an error — it's the price quote. Read it, pay it, retry.
- tools/list stalls — the server is probably building its list at runtime. Static, published manifests answer fast; that's the operator's fix to ship, and a reason to prefer servers that publish one.
FAQ
Can I use a remote MCP server without an API key or account? Yes — x402 servers replace credentials with payment. OMNIGATE's free tools need nothing at all; its paid tools answer with a 402 challenge your wallet settles in USDC. OAuth servers do require an account, because the token maps to your identity.
What does a remote MCP server cost per call? Whatever the challenge says, before the call executes. On OMNIGATE today: free for the five read-only tools, $0.005 for a Spend Gate check, $0.01–$0.25 for a Coherent Gate scoring, $0.25 for a Verdict decision. Keyed providers bill through their own dashboards instead — you find out at invoice time, not at call time.
How do I test a remote server before wiring it into my agent? Send the three calls by hand: an initialize POST, tools/list, then one tools/call. Expect a 402 — not an error — from any paid tool on an x402 endpoint, and judge the server by whether its prices and payee are printed where your agent can read them before spending.
ScriptMasterLabs builds remote MCP servers for the agent economy — 24 servers, 182 tools, priced per call in USDC. Start at muse-connect, browse the full catalog, or connect OMNIGATE and read its contract for free.