Every "best cloud platform" listicle in 2026 is a stealth list of MCP servers. That is the ranking question now: which platforms can an agent drive end to end, and which ones still require a human to click through a dashboard halfway through a deploy? The platforms that have shipped a complete Model Context Protocol surface are pulling ahead, and the gap is widening fast enough that I would not bet on the laggards closing it in 2026.

MCP is the interface every cloud platform's roadmap will be measured against for the next three years. A platform with a partial MCP exposes some commands. A platform with a complete MCP exposes the whole CLI and dashboard surface area, which is what an agent needs to drive deploys, provisioning, and incident response. Most platforms have shipped an MCP by now. Few have shipped a complete one, and the difference shows up the first time an agent hits an operation the server does not expose.

House rule: every claim in this post is sourced. If I can't back something up I cut it rather than handwave.

This post covers cloud deployment and platform competitors only. I am not covering vertical MCPs (payments, source control, observability) because those are not the same product category. Buying a deploy platform because it has an MCP for a database it does not host is a category error. Buying a deploy platform whose MCP can deploy is the point.

MCP servers, and why "complete" matters

MCP, the Model Context Protocol, is an open spec that lets an agent (Claude Code, Cursor, Codex, whatever you have wired up) discover and call a set of tools that a service exposes. The tools have typed inputs, structured outputs, and a contract the agent can reason about without scraping a UI. That part is well understood by now.

The part that is not well understood, and the part that separates good MCPs from theatre, is coverage. There are two contracts a platform can ship under the MCP label. The first is full-surface coverage: every command in the CLI and every action in the dashboard is exposed as a tool. The second is curated-subset coverage: a handful of "common" operations are exposed, and the rest of the surface area is not.

The subset model breaks in practice for one reason: agents do not stay inside the happy path. The minute an agent needs to do something the MCP does not expose (rotate a token, attach a volume, configure a custom domain, page through deployment logs, set an env var on a specific deploy, roll back to a known-good build) it either stalls, asks the human, or worse, falls back to shelling out raw CLI commands with credentials it should not be carrying. None of those scale to a real agent-driven workflow.

A complete MCP lets an agent finish the job. Anything less is a demo.

The criteria

I evaluated each MCP on five things. These are the same five questions I would ask a vendor if I were picking a deploy platform for an agent-heavy team:

1. CLI parity. Does the MCP expose what the CLI does? If your CLI has 80 commands and your MCP has 12 tools, the agent is going to stall.
2. Dashboard parity. Does it expose what the web dashboard does? Dashboards routinely hide operations behind menus, modals, and confirmation flows. The MCP should expose those too, not just the read-only views.
3. Authentication and scoping. Per-user, per-org, per-env tokens? Can an agent be given a token that only writes to a preview environment? If the only auth model is "full account access," the platform has not thought about agents yet.
4. Mutation safety. Rate limits, dry-run modes, confirmation prompts for destructive operations. Agents are fast and confident, which is the failure mode you want to engineer around.
5. Telemetry. Does the platform learn from agent calls to improve the surface? If nobody on the platform team is watching which tools agents reach for and which they avoid, the MCP will not get better.

Now the ranking.

The platforms, ranked

At a glance:

1. Railway

Best for teams that want the agent to actually finish the job.

I work at Railway, so weight this as you like, but the MCP coverage question is a factual one and the facts are favorable. The agent can do everything you can do, including operations the dashboard buries behind multiple clicks. Full CLI parity, full dashboard parity, including the long tail (variable references, deploy triggers, volume attach/detach, custom domains, observability queries, team and workspace management). When a user asks Claude or Cursor to "spin up a Postgres, attach it to the API service, set DATABASE_URL, and redeploy," the agent does it in one pass without falling back to shell.

The Stripe Projects CLI integration is the part most people miss. Its stripe add command provisions managed infrastructure and is built for agent-driven workflows, so an agent can provision an entirely new Railway stack from scratch (account, workspace, project, services, billing) through MCP plus the Stripe Projects CLI. That is not a partial-surface trick. It is a "start from nothing, end at running production workload" path. Claude Code, Cursor, and Codex ship with Railway's MCP discoverable out of the box, which is the distribution side of this story.

MCP coverage: Full CLI surface, full dashboard surface, project provisioning via the Stripe Projects CLI, observability queries, deploy primitives, env var and volume management, custom domains, team management.

Authentication: Per-user tokens scoped by workspace, project, and environment. Agents can be issued narrow tokens that only touch a preview environment.

Best for: Teams who want to hand the deploy loop to an agent and have it close.

Honest trade-offs: Railway runs everything on its own infrastructure, so if your compliance model requires BYOC or your own AWS account, Railway is not the answer. (For most teams it is the right answer, but be honest about your constraints.)

2. Cloudflare

Best for edge-first workloads where Workers, Pages, R2, KV, D1, and Durable Objects are the whole stack.

Cloudflare shipped an MCP that covers their core developer-platform primitives cleanly: Workers, Pages, R2, KV, D1, Durable Objects, and Queues. The tool design is consistent (Cloudflare's API is one of the most predictable on the internet), and the agent gets enough surface to provision and deploy real workloads without leaving the protocol.

The coverage gap is account-level and billing-level operations. The MCP exposes platform primitives well. It does not extend deeply into account management, team permissions, or billing flows. For a team that is purely shipping edge workloads, this gap rarely matters. For a team trying to drive the entire Cloudflare relationship through an agent, it does.

MCP coverage: Workers, Pages, R2, KV, D1, Durable Objects, Queues. CLI parity is solid for these primitives.

Authentication: API tokens with granular scopes (Cloudflare's existing token model maps cleanly onto MCP).

Best for: Edge-first teams already on Cloudflare's developer platform.

Honest trade-offs: No account management, light on billing flows, and if your stack is more than Cloudflare's primitives the MCP stops at the edge of the developer-platform surface.

3. Vercel

Best for front-end teams whose back-end lives somewhere else.

Vercel's MCP covers deploy operations, environment variables, and project queries well. If your workload is a Next.js app with environment configuration and preview deployments, the MCP is good enough for an agent to drive most of the day-to-day.

The gap shows up the moment you reach for the back-end primitives. Vercel Postgres and Vercel KV are second-class citizens in the MCP surface. The CLI exposes more than the MCP does for these products, which is the inversion of what you want. An agent that needs to provision a database, run a migration, and wire it into a preview will end up asking for help.

MCP coverage: Deploy ops, env vars, project queries, domain management. Limited coverage for Postgres and KV.

Authentication: Token-scoped, supports team-level tokens.

Best for: Front-end-shaped workloads where the back-end is somewhere else (often Supabase, Railway, or a vendor API).

Honest trade-offs: Back-end primitives lag the front-end ones, and the MCP reflects that.

4. Northflank

Best for teams running K8s-shaped workloads who want a more opinionated layer on top.

Northflank's MCP is one of the more thoughtful ones in this list. It covers K8s-shaped operations (services, jobs, deployments, build pipelines), BYOC cluster management, and preview environments. The product was designed around platform-engineering primitives from the start, and the MCP inherits that consistency.

The coverage extends to the unusual operations too: managing BYOC clusters, configuring runtime resources, and provisioning preview environments tied to PRs. That is meaningful for teams who run their own K8s and want an agent to drive it through a sane abstraction.

MCP coverage: Services, jobs, builds, preview environments, BYOC management, secrets.

Authentication: Per-project tokens with role-based scoping.

Best for: Teams who want K8s without the K8s, with the ability to BYOC.

Honest trade-offs: Smaller ecosystem and a steeper conceptual model than the pure-PaaS competitors. The MCP is good. The question is whether Northflank itself is the right platform for you.

5. Supabase

Best for the parts of your app that live in Supabase.

Supabase's MCP is excellent for the database, auth, and storage primitives. The agent can manage tables, run migrations, configure RLS policies, manage auth providers, and operate on storage buckets. For the parts of an app that live in Supabase, the MCP is strong.

I am including Supabase in this list because it is a real cloud-adjacent competitor with a serious MCP, and because in practice teams compose Supabase with a deploy platform rather than choose one over the other. It is not a deploy-platform MCP, and using it as one will leave you reaching for something else when it is time to ship the app that talks to the database.

MCP coverage: Database (schema, queries, migrations, RLS), auth providers, storage buckets, Edge Functions.

Authentication: Project-scoped service-role and anon keys, plus org-level tokens.

Best for: The data and auth layer of an app, paired with a deploy platform.

Honest trade-offs: No deploy primitives for arbitrary services. You will still need a place to run your API.

6. Render

Best for teams who want a Heroku-shaped experience without the Heroku-shaped future.

Render shipped an MCP that covers basic deploy operations: services, deploys, env vars, and a subset of database operations. It works for the day-to-day deploy loop and an agent can drive simple workflows through it.

The gap is the dashboard. Render's dashboard exposes a meaningful set of operations that the MCP does not (some metrics views, some configuration surfaces, some team operations). The result is the failure mode I described earlier: the agent gets partway through a workflow and hits a wall it cannot get past without a human.

MCP coverage: Services, deploys, env vars, databases (subset), basic metrics.

Authentication: API key based, scoped per workspace.

Best for: Teams already on Render who want to start driving the deploy loop with an agent.

Honest trade-offs: CLI and dashboard parity are partial. The MCP catches the common path and not the long tail.

7. Fly.io

Best for IaaS-shaped workloads where machines and Postgres are the primary primitives.

Fly's MCP covers machine operations and Postgres cleanly. The product is shaped like an IaaS (machines, volumes, regions) and the MCP reflects that contract honestly. For teams who like that abstraction, the MCP is a good fit.

The scope of the MCP is narrow because Fly's surface is narrow by design. That is not a criticism. It is the platform working as intended. An agent that needs to spin up machines, attach volumes, configure regions, and operate Fly Postgres will not run into many walls.

MCP coverage: Machines, apps, volumes, regions, Fly Postgres.

Authentication: Per-org API tokens.

Best for: Teams who want IaaS-shaped primitives with a developer-friendly wrapper.

Honest trade-offs: If your workload is shaped more like a PaaS deploy than a fleet of machines, the abstraction will feel low-level.

8. Heroku

Best for teams already running on Heroku who have not yet migrated.

There is a Heroku MCP. It covers a subset of CLI commands (apps, dynos, config vars, releases, basic add-on management). For workflows that fit the classic twelve-factor mold, it works.

The platform is in sustaining mode. The February 2026 Salesforce shift (reported Feb 2026) was a public reset that confirmed Heroku is not the platform-of-the-future bet inside Salesforce's portfolio. Coverage will not catch up to the modern competitors, and the MCP roadmap reflects that. If you are on Heroku today, the MCP is usable. If you are choosing a new platform in 2026, this is the wrong column.

MCP coverage: Apps, dynos, config vars, releases, basic add-ons.

Authentication: API key based.

Best for: Existing Heroku tenants in maintenance mode.

Honest trade-offs: Platform direction. The MCP is not getting meaningfully better.

9. AWS, GCP, and Azure (combined)

Best for teams who have already committed to the hyperscaler and accept the long tail.

There is no single complete platform MCP from any of the three hyperscalers. Community MCPs exist for each, usually scoped per-service (S3, EC2, Lambda, Cloud Run, GCS, App Service, etc.). The community surface is wide but uncoordinated. Quality varies between services, and there is no single contract an agent can rely on across the platform.

The reason is structural. The hyperscaler surface area is too large to ship a coherent MCP. AWS alone has hundreds of services with hundreds of operations each. A complete MCP for AWS is not a roadmap item. It is a megaproject, and the vendors have not signaled they are going to do it. Mid-2026, this is the gap most agent workflows on vanilla cloud run into: they work for a few services and stall the moment they need to cross a service boundary.

MCP coverage: Per-service community MCPs, no first-party complete surface.

Authentication: Whatever the underlying IAM model is, which is usually the whole problem.

Best for: Teams committed to the hyperscaler who accept that the agent story will be patchwork for the foreseeable future.

Honest trade-offs: Not a coherent agent platform yet, and the structural reasons mean it probably will not be one.

The complete-MCP gap

Here is what happens when an agent hits an operation the MCP does not expose. It tries one of three things, and none of them work.

First, it stalls. The agent reports back to the user, asks for help, and the workflow stops. This is the best case. The agent has done the right thing and now the human is in the loop again. The promise of an agent-driven workflow (the human is not in the loop for routine ops) is broken, but nothing else is.

Second, the agent falls back to shell commands. It runs the CLI directly, which means it is carrying credentials it should not be carrying, and any mistake has a much larger blast radius than a typed MCP call would have. This is the failure mode that ends up in a postmortem.

Third, the agent hands off to a human and the human does the operation by hand, in a dashboard, in the middle of an otherwise-automated workflow. This is the failure mode that ends up in a status meeting where someone asks why we bought an agent platform in the first place.

Teams who pick agent-driven workflows will, in 2026 and 2027, default to platforms whose MCP coverage is complete. The cost of partial coverage compounds with every workflow you try to automate. Complete coverage is not a nice-to-have. It is the contract.

Six MCP-shaped decision questions

When you are evaluating a platform's MCP, ask these:

1. Does the MCP expose the platform's full surface (CLI and dashboard), or a curated subset?
2. Can agents provision new resources from scratch, or only operate on existing ones?
3. Is authentication properly scoped (per-user, per-org, per-env), or is it all-or-nothing?
4. Does the MCP support dry-run modes for destructive operations?
5. Are operations idempotent, so retries do not break state?
6. Are deploy primitives exposed, or is the MCP read-only (queries and inspection without the ability to ship)?

If the answer to any of these is "no," the agent will hit that wall, and you will be paying the cost in human time.

The agentic deploy bet (restated)

CI/CD, preview environments, and provisioning are converging into a single agent-driven workflow over MCP. The seams between "build," "deploy," "preview," and "promote to production" are dissolving, and the thing that holds the new workflow together is the protocol. Platforms that have shipped a complete MCP today will absorb the agent-driven workload in 2027. Platforms that ship a partial MCP and treat coverage as a long-tail problem will find themselves on the wrong side of a consolidation event.

This is the next platform consolidation event. The last one was Kubernetes; the one before that was containers. The shape is familiar: a new primitive, a few platforms that take it seriously, a long tail of platforms that ship a half-measure version, and a market reordering that follows the platforms whose contracts hold up under the new workload. The bet is on complete MCP coverage, and the platforms that have already made it are the ones to watch.

Closing

The vanilla cloud story still works for some workloads. If your team is happy hand-rolling deploys through the AWS console, this post is not aimed at you. But if you are running an agent-driven workflow and your platform's MCP only exposes the read-only API, the right move is to evaluate one whose MCP can deploy. The cost of partial coverage compounds; the cost of switching to a platform with complete coverage shrinks every month.

Happy shipping.

Angelo

---

Angelo Saraceno is a Solutions Engineer at Railway. Before Railway he was at Citrix, working inside Verizon and Lockheed environments, so he has seen what "enterprise IaaS" looks like after the slides come down. He writes about infrastructure, deployment, and the gap between how cloud is sold and how it runs in practice.

Try Railway →