Preface¶

When pushing a local project to the cloud, you often need to repeatedly confirm the runtime, build commands, environment variables, and database dependencies. Render uses Git repositories to drive services, and uses render.yaml (Blueprint) to describe the entire infrastructure; single services can also be created directly through the Dashboard or MCP. Writing these configurations manually is not difficult, but it is easy to miss fields, forget to mark secrets, or forget to push the configuration to the remote repository first.

render-deploy is an Agent Skill designed for AI programming assistants: it analyzes the codebase in a fixed workflow, generates or verifies the Blueprint, uses MCP to create services directly if necessary, and provides deep links to the Render Dashboard to help you turn “it runs locally” into “it has been deployed”. It complements deployment Skills for Vercel and Cloudflare, covering the complete deployment path on the Render platform.

What is this¶

render-deploy is included in the skills/.curated/ directory of OpenAI’s openai/skills repository, and uses the standard SKILL.md format. It can be used in tools that support Agent Skills such as Cursor, Codex CLI, and Claude Code.

The official one-sentence positioning: Deploy applications to the Render cloud platform by analyzing the codebase, generating render.yaml Blueprints, and providing deep links to the Dashboard. It is suitable to enable this Skill when the user mentions deployment, hosting, publishing, or building applications on Render.

The same set of capabilities is also maintained in the Render official Skills directory render-oss/skills; Render’s documentation recommends installing the full set of Render Skills via the Cursor plugin or npx skills add render-oss/skills. The following description will focus on the curated version in openai/skills, and the workflow and core commands are consistent with the official version.

Core Features and Highlights¶

The Skill explicitly covers Git-driven two deployment paths:

Blueprint Method: Analyze the repository to generate render.yaml, which uses infrastructure-as-code to describe resources such as Web, Worker, Cron, static sites, private services, and databases; after verifying, committing, and pushing, use the Dashboard deep link to open the Blueprint creation page to complete the Apply.
Direct Creation (MCP): Suitable for scenarios with a single service, no independent Worker/Cron, no mounted databases/Key Value, and simple environment variables; create services directly through the Render MCP tool without first writing render.yaml to disk.

The heuristic selection logic is roughly: use Direct Creation when all conditions are met; use Blueprint whenever there are multiple services, databases, scheduled tasks, background Workers, private services, or the need for reproducible IaC. When in doubt, Blueprint is the safer default.

Other verified key points:
- Blueprint can use runtime: image to reference pre-built images, but render.yaml must still be placed in the Git repository.
- MCP cannot create pure image services; image deployments need to go through the Dashboard/API, or switch to the Git solution with Blueprint.
- When there is no Git remote, the process will pause and require pushing to the remote first, or switching to Dashboard/API for image deployment.
- The default plan: free; secret environment variables use sync: false and will be filled in by the user in the Dashboard.
- After deployment, you can use MCP to check list_deploys, list_logs, and get_metrics for basic acceptance checks; for deeper troubleshooting, you can use the render-debug Skill.

Installation and Activation¶

Install the Skill¶

The universal Skills CLI (vercel-labs/skills, skills.sh) can install curated Skills by name:

npx skills add https://github.com/openai/skills --skill render-deploy

You can also specify a specific agent, for example:

npx skills add openai/skills --skill render-deploy --agent cursor
npx skills add openai/skills --skill render-deploy --agent claude-code
npx skills add openai/skills --skill render-deploy --agent codex

In Codex, you can also use the $skill-installer from the repository description to install by curated name:

$skill-installer render-deploy

After installation, restart or refresh according to the requirements of the tool you are using to load the new Skill.

If you want to use the Render official directory directly (including render-deploy and supporting Skills such as debug and blueprints), the preferred Cursor path given in Render’s documentation is to run /add-plugin render in the chat, or:

npx skills add render-oss/skills

Configure Render MCP (Recommended for Single Service Direct Connection)¶

Direct Creation relies on Render MCP. The Skill requires that list_services() can be called first; if it fails, it will guide you to configure MCP. The API Key comes from:

https://dashboard.render.com/u/*/settings#api-keys

Cursor: Write to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "render": {
      "url": "https://mcp.render.com/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}

Restart Cursor and retry list_services().

Claude Code:

claude mcp add --transport http render https://mcp.render.com/mcp --header "Authorization: Bearer <YOUR_API_KEY>"

Codex:

export RENDER_API_KEY="<YOUR_API_KEY>"
codex mcp add render --url https://mcp.render.com/mcp --bearer-token-env-var RENDER_API_KEY

After configuration, set the workspace using natural language, for example: Set my Render workspace to [WORKSPACE_NAME]. For multiple workspaces, you can also confirm via MCP’s list_workspaces() / get_selected_workspace(), or via the CLI’s render workspace current / render workspace set.

Render CLI (Blueprint Validation)¶

render --version

If it is not installed:

# macOS
brew install render

# Linux / macOS
curl -fsSL https://raw.githubusercontent.com/render-oss/cli/main/bin/install.sh | sh

render whoami -o json
# or
export RENDER_API_KEY="rnd_xxxxx"
# or
render login

Typical Usage¶

1. Trigger via Natural Language¶

Just state your request directly in the conversation where the Skill is installed, for example:

Deploy this project to Render, show me the Blueprint first, then give me the Dashboard link.

Or:

This is a single-service Node application, create it directly to Render using MCP.

The Agent will first confirm whether it is a Git repository or a pre-built image, whether a database/Worker/Cron is needed, etc., then choose between Blueprint or Direct Creation.

2. Blueprint Main Workflow (Multiple Services / IaC)¶

Analyze the codebase: Identify the framework and runtime, build/start commands, environment variables, data storage, and port binding (Web services need to listen on 0.0.0.0:$PORT).

Sample render.yaml generated (basic structure from the Skill documentation):

services:
  - type: web
    name: my-app
    runtime: node
    plan: free
    buildCommand: npm ci
    startCommand: npm start
    envVars:
      - key: DATABASE_URL
        fromDatabase:
          name: postgres
          property: connectionString
      - key: JWT_SECRET
        sync: false  # Filled in by user in Dashboard

databases:
  - name: postgres
    databaseName: myapp_db
    plan: free

Supported service types include: web (public HTTP), worker (background tasks), cron (scheduled tasks), static (static site/CDN), pserv (private service within the account).

Validate:

render whoami -o json
render blueprints validate

Commit and Push (the deep link will read the Blueprint from the remote repository, and it will fail if not pushed):

git add render.yaml
git commit -m "Add Render deployment configuration"
git push origin main

Generate Dashboard Deep Link: First get the HTTPS-formatted repository address (SSH needs to be converted and the .git suffix removed):

git remote get-url origin

Deep link format:

https://dashboard.render.com/blueprint/new?repo=<REPOSITORY_URL>

For example:

https://dashboard.render.com/blueprint/new?repo=https://github.com/username/repo-name

Then complete Git OAuth in the Dashboard, fill in the secrets marked sync: false, check the resource configuration, and click Apply. Deployment may take a few minutes; if the sandbox blocks external networks, the Skill will prompt to retry related network calls with higher permissions (such as sandbox_permissions=require_escalated).

3. Direct Creation (Single Service)¶

The premise is still that the code has been pushed to GitHub / GitLab / Bitbucket. After analyzing the runtime and commands, the Agent will use MCP to create the Web or static site and necessary resources, configure environment variables, and use deployment status, logs, and metrics for acceptance checks. Image-based services do not use this workflow.

Applicable Scenarios and Notes¶

Suitable for:
- Applications that have been or are about to be pushed to GitHub/GitLab/Bitbucket and want to go live on Render.
- Need combinations such as Web + Worker + Cron + database, and want to use render.yaml for versioned management.
- Quick trial of a single service, and Render MCP has been configured.
- Want AI to follow the checklist to complete port checks, secret marking, Blueprint verification, and post-deployment log verification.

Notes:
- When there is no Git remote, the Blueprint / MCP Git workflow cannot continue. You need to create a remote first or switch to Dashboard/API for image deployment.
- You must confirm that render.yaml is in the remote repository before using the deep link, otherwise Render cannot read the configuration.
- MCP does not support creating image-backed services.
- Do not write secrets into YAML in plain text, use sync: false or inject them via Dashboard/MCP.
- Web services must correctly bind 0.0.0.0:$PORT; if the health check fails, first check the environment variables and ports.
- The README of the openai/skills repository has marked the overall migration direction (examples and plugins shall prevail based on OpenAI Plugins and other documents); for daily use, you can also refer to Render’s Cursor Integration Guide and render-oss/skills.

Summary¶

render-deploy breaks down Render deployment into a repeatable Agent workflow: analyze the repository → choose Blueprint or MCP direct connection → generate/verify configuration → push → Dashboard deep link or MCP creation → log and metric acceptance. For developers who are familiar with Render and want AI to tie together IaC and release steps in the editor, it fills the gap corresponding to the deployment Skills for Vercel and Cloudflare.

Official address (OpenAI curated):
https://github.com/openai/skills/tree/main/skills/.curated/render-deploy

The same-name Skill in the Render official Skills directory:
https://github.com/render-oss/skills/blob/main/skills/render-deploy/SKILL.md

For the Blueprint specification, please refer to the Render documentation:
https://render.com/docs/blueprint-spec

`render-deploy`: Analyze codebase, generate Blueprint, and deploy applications to Render