MCP Scaling: A Registry vs. Your Own Gateway
Quick answer: A registry and a self-hosted gateway scale in different places. A managed registry scales the control plane for you, so adding a server is a registration step and the vendor runs the data plane inside its o
Quick answer: A registry and a self-hosted gateway scale in different places. A managed registry scales the control plane for you, so adding a server is a registration step and the vendor runs the data plane inside its own quotas and regions. Your own gateway gives direct control over data-plane capacity, but every added node brings load balancing, shared state, and long-lived connection handling, and none of it adds capacity past the upstream MCP server. Pick the registry when you want to avoid running that layer; pick your own gateway when you need control the platform does not expose.
What scaling an MCP deployment actually means
Scaling is not one number. Split the system into a control plane and a data plane. The control plane tracks which servers exist, their versions, keys, and owners. The data plane carries the actual tool calls over streamable HTTP or SSE. Watch two capacities on the data plane: the count of long-lived connections agents hold open, and the rate of in-flight calls over them. A deployment that looks idle by request rate can already be at its connection limit, and adding servers to the catalog serves no extra call until the data plane can route and process it.
The registry path: scaling inside someone else's control plane
With a managed registry, you scale by publishing more servers and raising the allocations behind them rather than running more machines. The vendor keeps the control plane available and runs the data plane behind its own load balancing, so a new MCP server is a control-plane entry pointing at a running deployment. Your ceiling is now the vendor's ceiling: per-tenant quotas, supported transports, regions, and how fast support can lift a limit. You cannot add a node yourself at midnight.
Powerduck Cloud takes the control-plane side of this model. Each uploaded spec becomes hosted docs and a hosted MCP endpoint that stays off until you expose it, with version history and rollback, Git sync, and a separate agent key per server, so growing from one hosted server to several stays a set of control-plane actions. The comparison hub places this model among the wider trade-offs.
How the two paths scale side by side
| Scaling dimension | Managed registry | Your own gateway |
|---|---|---|
| Adding a server | Registration entry | Route config plus capacity plan |
| Data-plane nodes | Vendor operates them | You add and balance them |
| Long-lived connections | Managed for you | Draining and routing on you |
| Shared state | Held by the platform | External store you must run |
| Capacity ceiling | Vendor quotas and regions | Bounded by the upstream server |
The self-hosted path: where the bottlenecks move
Running your own gateway, the proxy itself can stay stateless and scale horizontally behind a load balancer, which is the part that looks easy. The hard part is everything that holds memory. SSE and streamable HTTP keep connections open, so a node that restarts drops live agents unless you drain them, and any shared counter, session cache, or routing table moves into an external store every node reaches. That store becomes a new bottleneck and failure domain.
Add nodes only against a measured limit. The gateway is one hop in a chain, so if the upstream server or its backend saturates first, more gateway nodes return errors faster rather than serving more calls. Connection count, in-flight requests, and latency point at different tiers, and scaling the wrong one changes nothing for the caller.
Honest limits
Neither path removes the backend ceiling. A registry makes registration cheap but does not promise data-plane headroom for every server you publish, and a self-hosted gateway can be made wide while the upstream stays narrow. High availability and lifecycle are separate settings you configure, not free effects. Treat vendor scale claims as quotas to verify, and keep per-server metrics on connections, in-flight calls, and latency so growth follows a measured bottleneck rather than a guess.
Frequently asked questions
Does adding servers to a registry increase my capacity? It adds entries to the control plane, not data-plane throughput. Capacity rises only when the platform allocations behind those servers can handle the new traffic, so check the quota behind each deployment instead of counting registered servers.
If my gateway is stateless, can I always scale it out? You can add gateway nodes, but shared state, the load balancer, and long-lived connections still need handling, and none of it helps once the upstream MCP server is the bottleneck. A stateless proxy does not mean a stateless system end to end.
What should I measure before scaling? The bottleneck's location. Compare open connections, in-flight calls, and latency at the gateway and at the upstream, because adding capacity to the wrong tier is expensive and changes nothing for the caller.
The bottom line
The registry versus your own gateway is really a choice about who owns the data plane and where your ceiling lives. A managed registry trades direct control for fast growth inside vendor quotas, which fits a team that does not want to run connection management and shared state. A self-hosted gateway fits when you need control the platform withholds, as long as you treat the upstream server, not the proxy, as the real capacity limit. Measure the bottleneck first, because neither approach lets you scale past the backend.
Originally published by Dev.to WebDev. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.