# Cloud platform plugins and skills for AI coding agents

> Install official coding-agent plugins, skills, and MCP servers for Cloudflare, Railway, DigitalOcean, Render, AWS, Azure, and Google Cloud.

Author: [Flavio Copes](https://flaviocopes.com/about/) | Published: 2026-07-31 | Topics: [AI](https://flaviocopes.com/tags/ai/) | Canonical: https://flaviocopes.com/cloud-platform-plugins-ai-coding-agents/

[Vercel has a plugin](https://vercel.com/plugin) that turns a coding agent into a Vercel expert:

```bash
npx plugins add vercel/vercel-plugin
```

It works with Claude Code, Cursor, Codex, and other coding agents.

I wanted to know which other cloud platforms offer something similar.

The short answer: quite a few do. But they do not all mean the same thing when they say plugin, skill, or MCP server.

This is the list I found, using official repositories and documentation. It is a snapshot from July 2026. This space moves fast.

## Plugin, skill, or MCP server?

Before looking at the platforms, we need to separate three things.

An **Agent Skill** teaches the agent how a platform works. It usually contains Markdown instructions and references. It can also contain scripts or other resources. Installing a skill does not establish access to your cloud account.

An **MCP server** gives the agent tools. Depending on the server and its permissions, those tools may read logs, list projects, create resources, change environment variables, or trigger deployments.

A **plugin** is packaging for a specific agent. It may bundle skills, MCP configuration, commands, hooks, and specialized agents.

This difference matters.

Skills give the agent knowledge. MCP gives it access. A plugin can give it both.

## The quick list

| Platform | Install | What you get |
| --- | --- | --- |
| Vercel | `npx plugins add vercel/vercel-plugin` | Plugin with current platform knowledge and skills. Vercel MCP is separate |
| Cloudflare | Install Cloudflare from the Codex plugin library, or use `npx skills add https://github.com/cloudflare/skills` | The plugin bundles skills, commands, and MCP. The `npx` command installs skills only |
| Railway | `curl -fsSL agents.railway.com \| sh` | Railway CLI, skill, MCP configuration, and auth check |
| Supabase | `npx plugins add supabase-community/supabase-plugin` | Supabase skills and MCP server in one plugin |
| DigitalOcean | `npx skills add digitalocean-labs/do-app-platform-skills` | 12 App Platform skills. MCP is configured separately |
| Render | `render skills install` | 21 Render skills. An official hosted MCP server is also available |
| AWS | `aws configure agent-toolkit` | Installs selected AWS skills and configures AWS MCP. Plugin bundles are separate |
| Azure | Install the Azure plugin from the agent marketplace | Azure skills, Azure MCP, and Foundry MCP |
| Google Cloud | `npx skills add google/skills` | Official skills. Product plugins and managed MCP servers are separate |
| Netlify | Install Netlify from the Codex plugin library, or connect its remote MCP server | Codex plugin, MCP tools, and hosted Agent Runners |
| Fly.io | `fly mcp server --claude` | Experimental MCP server built into `flyctl` |
| Heroku | `heroku mcp:start` | Official local Platform MCP server. A hosted OAuth server is also available |

Now let's look at what each one does.

## Cloudflare

Cloudflare has one of the most complete alternatives.

If you use Codex, open `/plugins` and install Cloudflare. The plugin installs [Cloudflare Skills](https://github.com/cloudflare/skills) and registers Cloudflare's MCP servers.

You can also install the portable skills directly:

```bash
npx skills add https://github.com/cloudflare/skills
```

The repository includes skills for Workers, Pages, Wrangler, Durable Objects, R2, D1, KV, the Agents SDK, security, performance, and other parts of the platform.

Cloudflare also runs [managed MCP servers](https://developers.cloudflare.com/agents/model-context-protocol/cloudflare/servers-for-cloudflare/). The broad API server covers more than 2,500 Cloudflare API endpoints. There are also smaller servers for documentation, observability, DNS analytics, and other focused tasks.

The separation is useful:

- install the skills when you want better Cloudflare code
- connect MCP when you want the agent to inspect or change your Cloudflare account
- use Wrangler when the task depends on the local project

Cloudflare's own [Codex setup guide](https://developers.cloudflare.com/agent-setup/codex/) recommends this combination.

The MCP tools ask you to authenticate when they connect to your Cloudflare account.

## Railway

Railway has the simplest full setup after Vercel:

```bash
curl -fsSL agents.railway.com | sh
```

The installer sets up or reuses the Railway CLI, installs the `use-railway` skill, configures MCP for supported agents, and checks authentication.

If the Railway CLI is already installed, use:

```bash
railway setup agent
```

The [Railway agent integration](https://docs.railway.com/agents) works with Claude Code, Cursor, Codex, VS Code, Copilot, OpenCode, and several other agents.

The skill covers project setup, deployments, logs, variables, domains, storage buckets, metrics, and troubleshooting. Railway offers both a local MCP server and a hosted remote MCP server.

This is a real end-to-end integration. The skill explains how Railway works, while MCP and the CLI let the agent operate it.

## Supabase

Supabase uses the same universal plugin installer as Vercel:

```bash
npx plugins add supabase-community/supabase-plugin
```

The [Supabase plugin](https://supabase.com/docs/guides/ai-tools/plugins) bundles two parts:

- Supabase Agent Skills for Database, Auth, Edge Functions, Storage, Realtime, and Postgres best practices
- the Supabase MCP server for querying databases, managing migrations, and deploying Edge Functions

You can install only the skills if you do not want live account access:

```bash
npx skills add supabase/agent-skills
```

I like this approach. Start with knowledge. Add MCP only when the agent needs to work with a real project.

Supabase recommends connecting MCP to a development project. If you need to use it with real data, scope the connection to one project and use read-only mode when possible.

## DigitalOcean

DigitalOcean publishes [12 App Platform skills](https://www.digitalocean.com/blog/deploy-smarter-with-ai-app-platform-skills-on-digitalocean):

```bash
npx skills add digitalocean-labs/do-app-platform-skills
```

They cover application design, App Spec generation, deployment planning, databases, development containers, migrations, and production troubleshooting.

These skills are intentionally opinionated. For example, they prefer VPC networking, Dockerfiles, GitHub Actions, and credentials stored in GitHub Secrets.

DigitalOcean also provides [official MCP servers](https://docs.digitalocean.com/reference/mcp/) for App Platform, Droplets, databases, Kubernetes, Spaces, networking, and other services.

The local MCP package is `@digitalocean/mcp`. It requires Node 18+, npm 8+, and a suitably scoped DigitalOcean API token.

You choose which services to expose. This example enables App Platform only:

```json
{
  "mcpServers": {
    "digitalocean": {
      "command": "npx",
      "args": ["-y", "@digitalocean/mcp", "--services", "apps"],
      "env": {
        "DIGITALOCEAN_API_TOKEN": "<your_api_token>"
      }
    }
  }
}
```

Do not commit a configuration file containing the token. Use your MCP client's environment variable support when possible.

This `mcpServers` shape works in clients that use JSON MCP configuration, including Claude Desktop and Cursor. VS Code uses a `servers` root, while Codex uses `config.toml`. Adapt it to your client.

The skills and MCP servers are separate. The skills focus on App Platform knowledge. MCP provides broader access to the DigitalOcean API.

## Render

Render publishes a catalog of [21 official Agent Skills](https://github.com/render-oss/skills).

With Render CLI 2.10 or later:

```bash
render skills install
```

Alternatively, use the portable skills installer:

```bash
npx skills add render-oss/skills
```

The catalog covers deploys, Blueprints, Docker, web services, private services, workers, cron jobs, disks, domains, Postgres, Key Value, scaling, monitoring, debugging, and Heroku migrations.

Render also has an [official hosted MCP server](https://render.com/docs/mcp-server) at `https://mcp.render.com/mcp`. It works with OAuth in Claude Code, Codex, and Cursor.

The MCP server can create web services, static sites, cron jobs, Postgres databases, and Key Value instances. It can also trigger deploys, read logs and metrics, and run read-only Postgres queries. Other service types and most updates to existing resources are not supported.

Render also offers marketplace plugins for Codex, Cursor, and Claude Code. If your agent has a plugin library, search for Render there first.

## AWS

AWS provides an Agent Toolkit through the AWS CLI:

```bash
aws configure agent-toolkit
```

This requires AWS CLI 2.35 or later. The MCP proxy also requires `uv`.

The command runs an interactive wizard. It detects supported agents installed on your computer, installs the selected AWS skills, and configures the AWS MCP server. Add `--yes` to accept the defaults for every detected agent.

The wider [Agent Toolkit for AWS](https://aws.amazon.com/about-aws/whats-new/2026/06/aws-cli-agent-toolkit/) includes:

- more than 40 Agent Skills
- three plugin bundles
- the AWS MCP server

The MCP server exposes more than 15,000 AWS APIs. Calls use IAM permissions and appear in CloudTrail, so agent actions use the same security and audit system as other AWS operations.

This is the most enterprise-focused setup in the list. AWS treats agent access as infrastructure access, with permissions, conditions, and audit logs.

## Azure

Microsoft's [Azure Skills plugin](https://github.com/microsoft/azure-skills) combines three layers:

- skills for planning, validating, deploying, diagnosing, and optimizing Azure applications
- Azure MCP, with more than 200 tools across 40+ Azure services
- Foundry MCP for model deployment and AI agent workflows

In Claude Code, install the official Azure plugin:

```text
/plugin install azure@claude-plugins-official
```

In Codex, add Microsoft's marketplace from the terminal:

```bash
codex plugin marketplace add microsoft/azure-skills
```

Then open `/plugins` and install Azure.

GitHub Copilot CLI uses a different marketplace:

```text
/plugin marketplace add microsoft/azure-skills
/plugin install azure@azure-skills
```

Cursor has an Azure plugin in Settings → Plugins. Visual Studio and VS Code provide their own extension-based setup.

The interesting part is Azure's deployment flow. The agent creates a deployment plan under `.azure/`, waits for approval, validates the setup, and then deploys. The workflow makes the approval point explicit instead of jumping from a prompt to production.

For deployment, you need an Azure subscription, Node 18+, `az login`, and `azd auth login`.

Microsoft also publishes a much larger portable skills catalog:

```bash
npx skills add microsoft/skills
```

That repository is useful when you need a skill for a specific Azure SDK or language rather than the complete Azure operations plugin.

## Google Cloud

Google has an [official Agent Skills repository](https://github.com/google/skills):

```bash
npx skills add google/skills
```

It includes skills for Cloud Run, BigQuery, Cloud SQL, AlloyDB, Firebase, GKE, Gemini, authentication, onboarding, network observability, and the Google Cloud Well-Architected Framework.

This command installs selected skills. It improves the agent's Google Cloud knowledge, but it does not authenticate the agent or give it access to your projects.

The same repository also publishes product plugins for supported agents. Google separately provides managed remote MCP servers for Google Cloud services. Those require their own setup and authentication.

Google also publishes more focused skill packages. For example, [`google/agents-cli`](https://github.com/google/agents-cli) teaches coding agents how to build, evaluate, and deploy Agent Development Kit projects.

## Netlify

Netlify has a plugin in the Codex plugin directory. It lets Codex create projects, configure settings, inspect failed deploys, and deploy previews or production builds.

Netlify also runs a [remote MCP server](https://www.netlify.com/knowledge-base/netlify-for-coding-agents/). In Codex, add it with:

```bash
codex mcp add netlify --url https://netlify-mcp.netlify.app/mcp
```

For other supported agents, Netlify also recommends a generic interactive installer:

```bash
npx -y add-mcp https://netlify-mcp.netlify.app/mcp
```

The generic installer asks which agents to configure. Both paths require Netlify authorization before the agent can access your account.

The MCP server can work with deploys, Functions, Edge Functions, Blobs, Netlify Database, environment variables, and `netlify.toml`.

Netlify goes one step further with Agent Runners. Instead of connecting your local coding agent to Netlify, you can run Claude Code, Codex, or Gemini inside a Netlify project and review the resulting Deploy Preview.

## Fly.io

Fly.io does not currently publish a general Agent Skills or plugin bundle. But `flyctl` includes an [official experimental MCP server](https://fly.io/docs/mcp/flyctl-server/):

```bash
fly mcp server --claude
```

Use `--cursor`, `--vscode`, `--windsurf`, `--zed`, or `--neovim` for those clients. You can also pass `--config` with an explicit configuration path.

The server exposes operations for apps, certificates, logs, Machines, organizations, secrets, status, and volumes. It uses your Fly CLI credentials or `FLY_ACCESS_TOKEN`.

Fly.io does not currently document a Codex-specific setup path.

## Heroku

Heroku does not currently publish a portable Agent Skills package. It does provide [official Heroku Platform MCP servers](https://devcenter.heroku.com/articles/heroku-mcp-server).

OAuth-capable remote clients can connect to:

```text
https://mcp.heroku.com/mcp
```

For a local server, Heroku CLI 10.8.1 or later can use your current CLI login:

```bash
heroku mcp:start
```

There is also an API-key alternative:

```bash
npx -y @heroku/mcp-server
```

The Platform MCP server can manage apps, deploys, scaling, restarts, logs, Postgres databases, and add-ons.

Heroku's Managed Inference and Agents MCP toolkit is a separate product. It lets an application connect its model to custom MCP tools.

## Which one should you install?

My advice is to start with skills.

Skills improve generated code and configuration without opening access to a cloud account. They are useful even when you still deploy manually.

Add MCP when you want the agent to inspect real resources, read logs, or perform operations. Use OAuth or a narrowly scoped token. Start with read-only access when the platform supports it.

For production infrastructure, keep approval prompts enabled. A coding agent that can deploy an app can also replace environment variables, restart services, or create resources that cost money.

Read the repository before installing third-party skills or piping an installer into your shell. An Agent Skill can contain scripts and tool instructions, not just documentation. The `plugins` and `skills` installers are also interactive by default unless you pass flags to select targets and accept prompts.

The best integrations combine all three layers:

1. skills explain the platform
2. MCP exposes controlled operations
3. the CLI handles local project work

Vercel made this pattern easy to see. Cloudflare, Railway, Supabase, Render, AWS, Azure, Fly.io, Heroku, and others are now building the same bridge between coding agents and real infrastructure.
