# Using Render with Coding Agents — Deploy and manage apps using LLM-powered tools.

Render integrates with popular coding agents to help you manage your infrastructure, diagnose issues, and learn about the platform.

## Agent skills and plugins

Render's official *skills* enable agents to deploy, debug, and monitor your apps. These skills are also bundled into official marketplace *plugins* for Cursor, Codex, and Claude Code.

### Install

**Tab: Official plugins**

Render provides official plugins for *Cursor*, *Codex*, and *Claude Code*.

Open the plugin marketplace for your preferred tool (usually with `/plugins`) and search for `render`:

[image: Adding the Render plugin in the Claude Code plugin marketplace]

The plugin bundles Render's official skills and provides a unified interface for using them with your coding agent.

**Tab: Render CLI**

> *Requires version 2.10 or later of the [Render CLI](cli).*
>
> Check your current version with `render --version`

1. Run the following command:

    ```shell
    render skills install
    ```

2. The CLI detects supported tools on your system (Claude Code, Codex, Cursor, OpenCode) and prompts you to select which skills to install.

You can also specify options directly for non-interactive use:

```shell
render skills install --tool cursor --skill render-deploy --skill render-debug
```

See the [CLI reference](cli-reference#skills) for the full list of `skills` subcommands, including `update`, `remove`, and `list`.

**Tab: Install script**

Run the following script to automatically detect popular supported tools (Claude Code, Cursor, etc.) on your system and install Render's official skills for each:

```shell
curl -fsSL https://raw.githubusercontent.com/render-oss/skills/main/scripts/install.sh | bash
```

The output looks like this:

[image: Running the quick-install script]

**Tab: Manual installation**

##### Manual installation

1. Clone the [Render Skills GitHub repository](https://github.com/render-oss/skills).
2. From the repo's `skills/` directory, copy each skill directory into your tool's skills directory.

    Default skills directories for popular tools are listed below:

| Tool | Skills Directory |
| --- | --- |
| Claude Code | `~/.claude/skills/<skill-name>/` |
| Codex | `~/.codex/skills/<skill-name>/` |
| Cursor | `~/.cursor/skills/<skill-name>/` |
| OpenCode | `~/.config/opencode/skills/<skill-name>/` |

> Depending on your tool, you might need to restart it after installing.

After installing, your agent can automatically select and invoke skills to fulfill relevant prompts. You can also invoke a skill manually using your coding agent's syntax (usually a `/` or `$` symbol followed by the skill's name).

[image: Invoking the render-deploy skill in Codex]

### Supported skills

#### Render interfaces

| Skill | Description |
| --- | --- |
| *render-cli* | Install and use the [Render CLI](cli) for deployment and operations. |
| *render-mcp* | Connect and configure the Render MCP server for your coding agent. |

#### Service lifecycle

| Skill | Description |
| --- | --- |
| *render-deploy* | Deploy applications using IaC with Render Blueprints or directly via MCP. |
| *render-docker* | Build and deploy containerized services using Docker on Render. |
| *render-scaling* | Scale services with manual instance controls or autoscaling settings. |

#### Service diagnostics

| Skill | Description |
| --- | --- |
| *render-debug* | Debug deployment issues using logs, metrics, and database queries. Detects common issues like missing environment variables, port binding errors, and resource constraints. |
| *render-monitor* | Monitor service health, performance metrics, logs, and resource usage in real-time. |

#### Service config

| Skill | Description |
| --- | --- |
| *render-blueprints* | Author and validate `render.yaml` files for use with [Render Blueprints](infrastructure-as-code) for multi-service infrastructure. |
| *render-domains* | Configure custom domains and HTTPS/TLS for web services and static sites. |
| *render-env-vars* | Manage environment variables, secrets, and environment groups across services. |
| *render-networking* | Connect services over Render's private network using internal DNS and service discovery. |

#### Service types

| Skill | Description |
| --- | --- |
| *render-background-workers* | Configure queue-based background workers for asynchronous job processing. |
| *render-cron-jobs* | Set up and troubleshoot scheduled tasks using Render cron jobs. |
| *render-private-services* | Set up internal-only private services that are reachable on Render's private network. |
| *render-static-sites* | Deploy and configure static sites on Render's global CDN. |
| *render-web-services* | Configure and troubleshoot public web services on Render. |
| *render-workflows* | Set up, build, and deploy Render Workflows for distributed task execution. |

#### Datastores

| Skill | Description |
| --- | --- |
| *render-disks* | Attach and manage persistent disks for stateful workloads. |
| *render-keyvalue* | Provision and configure Render Key Value instances. |
| *render-postgres* | Set up and operate Render Postgres databases. |

#### Migration

| Skill | Description |
| --- | --- |
| *render-migrate-from-heroku* | Plan and execute migrations from Heroku to Render. |

### Example prompts

Ask your tool to perform any of these tasks:

> Deploy my application to Render

> Debug my Render deployment

> Is my Render service healthy?

Your tool will invoke the appropriate set of skills and guide you through the process.

### Skill source

## Render MCP server

Connect to Render's official MCP server to manage your Render infrastructure directly from apps like Cursor and Claude Code:

[video]

The MCP server provides tools for actions such as:

- Creating new services and redeploying existing ones
- Querying databases
- Analyzing metrics and logs

It's especially useful for helping you identify and resolve issues with service deploys.

## Jules integration

[Jules by Google Labs](https://jules.google/?utm_source=render) provides a managed integration with Render. Whenever you open a pull request in your service's repo, Jules can detect failures in your service's preview build and automatically push fixes to address them.

#### Prerequisites

- Your Render service's repo must be hosted on GitHub.
- Jules must have access to your service's repo.
- [Pull request previews](service-previews#pull-request-previews-git-backed) must be enabled for your service.
    - These are the preview builds that Jules uses to detect and address issues.

#### Setup

1. Go to [dashboard.render.com/jules](https://dashboard.render.com/jules).

    This opens the API Keys section of your user settings with a Jules-specific section:

    [image: Jules API Keys section]

2. Next to the *Jules by Google Labs* section, click *+ Create API Key*.

    A creation dialog appears.

3. Review and accept the terms for Render's Jules integration, then click *Create API Key*.

4. Copy the created API key to your clipboard.

5. Open your [Jules integrations page](https://jules.google.com/settings/integrations?utm_source=render):

    [image: Jules integrations page]

6. Under the *Render* integration, paste the API key you copied and submit it.

You're all set! Whenever a pull request preview fails for your repo, Jules will automatically analyze its logs to identify the root cause and push a fix to address it.

You can also *enable MCP features* to use Render's official [MCP server](mcp-server) with the Jules agent:

[image: Enabling MCP features in Jules]

You can disconnect the integration at any time by deleting the API key from the Jules integrations page.

## Documentation features

The Render documentation provides the following capabilities to improve content discoverability and parsing for agents:

### Articles as markdown

Each article under `render.com/docs/` is available in a simplified markdown format that's well suited for LLMs.

Obtain an article's markdown version by doing any of the following:

- Append `.md` to the end of an article's URL:

    ```
    https://render.com/docs/llm-support.md
    ```
- Include an `Accept: text/markdown` header in your request to an article's URL (no `.md` extension required).
    - Agentic tools like Claude Code often include this header in their HTTP requests by default.
- Click *Copy page* in the top-right corner of an article to copy its markdown version to your clipboard (not available on smaller screen widths).

### Reading `llms.txt` and `llms-full.txt`

The Render documentation includes `llms.txt` and `llms-full.txt` files at the following URLs:

```
https://render.com/docs/llms.txt
https://render.com/docs/llms-full.txt
```

| File | Description |
| --- | --- |
| [`llms.txt`](llms.txt) | Provides a summary of the Render documentation, including links and descriptions of each article. |
| [`llms-full.txt`](llms-full.txt) | Combines most of the Render documentation into a single, simplified markdown file. Some content types are omitted for brevity. |

### Docs via MCP

> *This feature is experimental.*
>
> Render might discontinue support for this documentation-specific MCP server at any time in the future.

Render's primary [MCP server](#render-mcp-server) does not yet provide tools for querying the Render documentation.

To query the Render docs from LLMs, you can connect your app or agent to the following additional MCP server:

```
https://mcp.inkeep.com/render/mcp
```

This MCP server provides "tools" for searching and asking questions about the Render docs. It uses the same LLM-powered answer engine as the *Ask AI* assistant in the documentation.

---

##### Appendix: Glossary definitions

###### environment variable

Config values you can apply to a service to customize its behavior at build and runtime, such as `NODE_VERSION` or `OPENAI_API_KEY`.

Render sets some environment variables for your service by [default](environment-variables).

Related article: https://render.com/docs/configure-environment-variables.md

###### private network

Your Render services in the same *region* can reach each other without traversing the public internet, enabling faster and safer communication.

Related article: https://render.com/docs/private-network.md

###### background worker

Deploy this *service type* to continuously run code that does not receive incoming requests.

Ideal for processing jobs from a queue.

Related article: https://render.com/docs/background-workers.md

###### cron job

Deploy this *service type* to execute a command or script on a predefined schedule.

Ideal for intermittent tasks like sending email digests or generating reports.

Related article: https://render.com/docs/cronjobs.md

###### private service

Deploy this *service type* to host a dynamic application that is not internet-reachable.

Ideal for internal apps that only your other Render services can access.

Related article: https://render.com/docs/private-services.md

###### static site

Deploy this *service type* to host a static website (HTML/CSS/JS) over a global CDN at a public URL.

Related article: https://render.com/docs/static-sites.md

###### web service

Deploy this *service type* to host a dynamic application at a public URL.

Ideal for full-stack web apps and API servers.

Related article: https://render.com/docs/web-services.md

###### Render Workflows

Define collections of long-running *tasks* that execute across distributed compute.

Ideal for agents, ETL pipelines, and background jobs.

Related article: https://render.com/docs/workflows.md

###### persistent disk

A high-performance SSD that you can attach to a service to preserve filesystem changes across deploys and restarts.

Disables [zero-downtime deploys](/deploys#zero-downtime-deploys) for the service.

Related article: https://render.com/docs/disks.md

###### Render Key Value

Fully managed, Redis®-compatible storage ideal for use as a job queue or shared cache.

Related article: https://render.com/docs/key-value.md

###### Render Postgres

Fully managed PostgreSQL databases that support point-in-time recovery, read replicas, high availability, and more.

Related article: https://render.com/docs/postgresql.md