Zed Industries

Generate videos in Zed

Three lines under context_servers, and Zed renders video. Renderly runs a hosted MCP server, so Zed renders from the templates you already built - and previews cost nothing.

5 free credits · no card · hosted MCP, nothing to install

Zedexample session

You

Take the three takeaways in lecture-06.md and make a lesson clip from them.

renderly_list_projects
Looks through your Renderly projects
1 match: Lesson Explainer, 7 dynamic variables
renderly_get_variables
Reads what that project expects
title, subtitle, point_1, point_2, point_3, tutor_name, outro

Your notes label them Takeaway 1 to 3. The project wants point_1 to point_3. I will map them and preview first, which is free.

renderly_preview_render0 credits
Checks the mapping without rendering
previewUrl ready, resolved 6/7, warning UNKNOWN_REPLACEMENT: takeaway_3

The third one did not match. Renaming it to point_3 and updating the same preview rather than making a new one.

renderly_preview_render0 credits
Updates the same preview in place
revision 2, resolved 7/7, no warnings, quote 1.5 credits

All seven applied. Open the preview with ?mode=grid to see every frame labelled. Shall I render the 1 min 20 s clip for 1.5 credits?

renderly_create_render1.5 credits
Renders the clip, once you confirm
job queued, 1080p, 1 min 20 s, 1.5 credits
renderly_get_render_status
Waits for the job to finish
completed in 2 min 11 s, download link returned

Done. lesson-06.mp4 is ready to download: 1 min 20 s at 1080p, 1.5 credits spent. The two free previews cost nothing.

2 previews, charged nothing1.5 credits spent, on the render alone

Zed is where a lot of writing now happens that is not code. Lecture notes in Markdown, a course outline, release notes, a changelog: they sit in a buffer with the agent panel open beside them, and the agent can already read that buffer, edit it and search the rest of the project. What it cannot do is turn any of it into a video file. Renderly's hosted MCP server adds that, and it adds it the way Zed prefers. One entry in settings.json. No local process to supervise, no npm package to keep current, no render pipeline of your own. Zed speaks to https://renderly.video/api/mcp directly. From then on the agent can list the projects you have already designed in Renderly, read the variable names each one exposes, fill them from the text in front of you, and check the result for nothing before it spends a credit. That check suits the way a Zed buffer gets edited: renderly_preview_render costs nothing, returns a public /p/ link and a credit quote, and calling it again with the same previewId updates that link in place, so a heading you rewrite in the Markdown file beside the agent panel can be re-checked for free. Zed also tells you the server is up rather than leaving you guessing. Open Settings, then AI, then MCP Servers, and the dot beside renderly turns green with the tooltip “Server is active”.

Renderly is the rendering engine, not the publisher. It hands back a finished MP4 at a URL - where that file goes next is up to you or one of our no-code integrations. The same engine and the same credits drive the REST API, so nothing about a render differs because Zed asked for it.

The free preview loop

Zed can check its work before you pay for it

An agent filling in a template will get something wrong - a mistyped variable name, a headline too long for its line. Renderly gives it a way to find out for nothing. A preview takes the same arguments as a real render and resolves them exactly the same way, but produces no video and costs no credits.

Preview0 credits
Fix, preview again0 credits
Once more0 credits
Rendercredits charged

It can look at the frames

Append ?mode=grid and the preview page draws a labelled contact sheet spanning the whole video, as ordinary images. Any agent that can open a page and screenshot it can then see a collided caption or a wrong colour - the failures no validator catches.

?mode=grid

Or one exact moment

Append ?frame=N to check a specific instant, where N is the second you care about multiplied by the frame rate. The page publishes its own rate, so the agent works it out rather than guessing from the nearest tile on the grid.

?frame=N

And fix it in place

Pass the previewId back with corrected values and the same preview updates. The link never changes, so the agent reloads and looks again. A revision counter goes up each time, which is how it knows it is seeing its own latest attempt and not a cached earlier one.

previewId

The warning that saves the most credits. If a variable name does not match, Renderly ignores it silently and renders the authored default instead - so the video comes back looking fine and carrying the wrong text. A preview returns a resolved map of what actually applied plus an UNKNOWN_REPLACEMENT warning, which is how Zed catches that before it becomes a charge.

Setup

Connect Renderly to Zed

Setup is either a few clicks in Settings → AI → MCP Servers or one block of JSON in settings.json. Both routes write the same entry under context_servers, so pick whichever you prefer.

settings.json (OAuth)

{
  "context_servers": {
    "renderly": {
      "url": "https://renderly.video/api/mcp"
    }
  }
}

This is the path Zed's own documentation uses in its examples. If you are unsure where yours is, run zed: open settings file from the command palette and paste into the buffer that opens. With no Authorization header set, Zed runs the standard MCP OAuth flow and opens your browser.

settings.json (API key variant)

{
  "context_servers": {
    "renderly": {
      "url": "https://renderly.video/api/mcp",
      "headers": {
        "Authorization": "Bearer rnd_your_key_here"
      }
    }
  }
}

Use this only when you want to skip the browser step. Adding the header suppresses the OAuth prompt, and the key is stored as plain text, so keep this file out of a shared dotfiles repository.

Open the command palette and run agent: open settings, then choose MCP Servers. Click Add Server in the page header, then Add Remote Server.
Enter the name renderly and the URL https://renderly.video/api/mcp. Leave the Authorization header field empty to get the OAuth flow, and approve the browser prompt from WorkOS AuthKit.
Or skip the UI: run zed: open settings file and paste the first JSON block in yourself. The name you choose becomes the key under context_servers.
Check the indicator dot next to renderly on the MCP Servers page. Green, with the tooltip “Server is active”, means Zed connected.
Ask the agent to run renderly_whoami. It should answer with your account email and your credit balance, which confirms both the connection and the sign-in.
Ask it to preview something before rendering. renderly_preview_render costs nothing, returns a public /p/ link that lasts 24 hours, and tells you which variables actually applied.

Either a browser sign-in or an API key

Either works, and they are an either/or by design. Zed starts the OAuth flow only when a remote server has no Authorization header configured, so leaving that field empty is what produces the browser prompt against WorkOS AuthKit. Add a headers block with a Renderly API key and Zed will send it on every request and never ask you to sign in. The trade-off is storage: Zed's context_servers examples show no environment-variable interpolation, so the key sits in settings.json as plain text. If that file is in your dotfiles repository, choose OAuth.

How this was checked. Server verified live on 2026-08-19: an unauthenticated POST returns 401 with an RFC 9728 challenge, WorkOS AuthKit advertises Dynamic Client Registration, and all ten tools are registered. The setup below was confirmed against Zed Industries's current MCP documentation and survived an independent adversarial recheck on the same date. Nobody here drove Zed end to end. Zed Industries’s documentation

The surface

Ten tools Zed gets

You never call these by hand. Zed picks the right one from what you asked for. They are listed because it is worth knowing which of them can cost you money - and that seven of the ten cannot.

They are thin wrappers over the same service layer the public REST API uses, so the two surfaces cannot drift apart.

Renderly MCP tools, what each does, and whether it costs credits
Tool	What it does	Cost
`renderly_whoami`Connect	Confirms the connection and reports your credit balance	free
`renderly_list_projects`Find	Lists your own projects that have something to personalise	free
`renderly_list_templates`Find	Lists the public system templates	free
`renderly_get_variables`Find	Reads which fields a template or project accepts, and their current values	free
`renderly_preview_render`Check	Resolves your values exactly as a render would, without producing a video - returns a public preview link, what actually applied, a credit quote and any warnings	free
`renderly_create_render`Render	Renders the video. Annotated as not read-only, so clients ask before calling it	credits
`renderly_get_render_status`Track	Polls the job and returns the finished video URL	free
`renderly_generate_captions`Add AI	Transcribes audio into word-synced captions you can drop straight onto a layer	credits
`renderly_generate_voiceover`Add AI	Turns a script into narration saved to your media library	credits
`renderly_get_ai_job`Add AI	Polls a captions or voiceover job for its result	free

Why Zed

What this client is good at

Zed keeps its whole configuration in a single settings.json - the file the zed: open settings file action opens - and many Zed users keep that file in a dotfiles repository. So adding Renderly here is a three-line diff that arrives on every machine you work from, reviewable in a pull request, with nothing installed alongside it. The key carries Zed's own name for these things: context_servers, because Zed calls them context servers rather than MCP servers, and a remote one needs only url, with no type field and no transport field to set. The second reason is the buffer. Lesson notes, a script, a spreadsheet exported as CSV, all already open and already in the agent's context, which is exactly the input a template needs. Zed handles the notifications/tools/list_changed message, so Renderly's ten tools reload at runtime rather than after a restart. And approval lives in that same file: agent.tool_permissions.default is confirm, and the per-tool key mcp:renderly:renderly_create_render keeps the prompt on the one tool that spends credits.

Questions people actually hit

Why is the key called context_servers and not mcpServers like everywhere else?

Zed calls them context servers, so the top-level key in settings.json is context_servers, not mcpServers and not servers. It sits at the root of the file, alongside your theme and language settings, rather than nested under an ai or agent block. Inside it, each server is named by you, and a remote server such as Renderly needs only url. There is no type field and no transport field to set. A local stdio server would use command, args and env instead, which is why the two shapes look different in Zed's own examples.

I cannot find the settings.json that Zed wants me to edit. Where is it?

Do not go hunting for it. Run zed: open settings file from the command palette and Zed opens the right one as an ordinary buffer, whatever your platform or install method. Zed's documentation uses ~/.config/zed/settings.json in its examples, which is the macOS and Linux location, but it does not publish a settings path for every platform, so we would rather not quote one at you. The other route avoids the question completely: add the server through Settings, then AI, then MCP Servers, and Zed writes the context_servers entry into that file for you.

How will I see Renderly's tools being called in the agent panel?

Once the entry is saved, Renderly appears as a context server under Settings, then AI, then MCP Servers, and its ten tools become available to the agent: renderly_whoami, renderly_list_templates, renderly_list_projects, renderly_get_variables, renderly_preview_render, renderly_create_render, renderly_get_render_status, renderly_generate_captions, renderly_generate_voiceover and renderly_get_ai_job. Zed supports MCP tools and prompts; resources are not on its supported list, so ignore any guide telling you to attach one. We mark renderly_create_render as not read-only, and Zed prompts anyway by default: agent.tool_permissions.default is confirm, which asks before any tool action, MCP calls included. To keep that prompt even after you set the default to allow, give the tool its own rule under the key mcp:renderly:renderly_create_render.

What do I type in the command palette to get to the MCP settings?

Open the command palette and run agent: open settings, then choose MCP Servers in the sidebar. From there, Add Server followed by Add Remote Server gives you two fields: a name, which becomes the key under context_servers, and a URL, which is https://renderly.video/api/mcp. Leave the Authorization header field empty and Zed will run the OAuth flow instead of sending a static token. If you would rather type JSON, run zed: open settings file and paste the block above. Both routes write the same entry.

A blog post told me to add "source": "custom" and run npx mcp-remote. Do I need that?

No, and it will only make things harder. That advice was written for an older Zed, and several third-party guides still repeat it, wrapping the endpoint in npx -y mcp-remote because that was once the only way to reach a remote server. Current Zed takes a bare url, does the RFC 9728 discovery itself against our 401 response, and completes OAuth with PKCE. No stdio bridge and no Node process is involved. If a plain url entry genuinely will not connect, update Zed before you reach for mcp-remote.

The same server, in every other client

One endpoint, one account, one credit balance. Only the wrapper changes.

Using something not listed? Any client that speaks remote MCP over Streamable HTTP can connect to https://renderly.video/api/mcp - these pages exist because the setup differs, not the server.

Let Zed render the next one

Build a template once, then describe what you want. Previews are free, so the first thing you spend a credit on is a video you have already seen.