Skip to main content
Cloud Blender runs Blender on Patch’s machines. Your coding agent starts a session, a live Blender 5.2 with no window, and drives it with bpy scripts. It can look at the scene as a picture, checkpoint and fork it, and render it on GPUs. You pay in credits, by the second, only while something runs. Your agent does the work, through pch or Patch’s MCP server. The app’s blender area is where you watch it and step in: what’s running, what it costs, pausing, stopping, going back to a checkpoint and downloading. Anyone signed in to Patch can use it. Your own org comes with 500 starter credits. 1 credit is $0.01.

Connect your agent

The quickest way is to give your agent this prompt. If it doesn’t have pch or Patch’s tools yet, it sets them up first, and you sign in through a link it gives you.
The same prompt is on the empty blender page in Patch, with a copy prompt button. To set it up yourself instead, each way below gives your agent the same tools. Any agent works: Claude Code, Codex, Cursor, their desktop apps, or the agent in a Patch Desktop chat, which is already connected as you.

With pch

Install pch and sign in:
The installer adds Patch’s MCP server to the coding agents on your PC (pch agent install does it again for one you add later). pch login makes a key that can spend credits (the compute scope), as well as read and publish. The commands are under pch blender and pch jobs. If pch blender isn’t there, run pch update. A key made before cloud Blender opened can only read: it can’t start, change, stop or download anything, and those calls answer missing_scope. Sign in again with pch login --scope read --scope publish --scope compute, then restart your agent.

With the MCP server

Apps that add an MCP server by address connect with your Patch account: add https://patch.gg/api/mcp, sign in to Patch when it asks, and press Connect. The sign-in screen says use tools with your credits, which means the app can spend credits. To connect with an API key instead, make one with compute and give it to your agent as the MCP server page shows:
Tell your agent to read the guide tool’s Cloud Blender section first. It covers how to use the tools well and what they cost.

A first session

The prompt above has your agent ask you what to make. To say it yourself, give your agent a prompt like this:
What you’ll see in Patch:
  • blender is in the sidebar, under analytics, for everyone, signed in or not. While anything runs, it shows how many.
  • The area at patch.gg/blender lists your sessions and jobs, with the tabs all, live, paused and stopped. Each row has the scene’s latest look, its state, its machine, who started it (your agent and its key) and when it was last active. Renders show under the session they came from.
  • A session’s page has its latest look, its checkpoints in a row with restore and fork, Blender’s logs and the files in /work, plus what it’s cost so far and what an hour of it costs. pause, checkpoint, fork and stop are at the top while it runs, and resume when it’s paused.

What an agent can do

Each step lists the pch command and the MCP tool. Run pch <command> --help for every flag. Some things to know about these:
  • Sizes. A session is small (2 cores, 4 GB) unless you ask for --size medium (4 cores, 16 GB) or --size large (8 cores, 32 GB). --gpu l40s adds a GPU. A fork is the size of its parent unless you say otherwise, so you can try something on a small session and fork it onto a GPU.
  • One GPU: an L40S. A session, a render or a batch script with a GPU has an l40s, which starts in seconds. Patch doesn’t offer an L4 any more, since one took up to 10 minutes to start: asking for one is refused (gpu_not_offered), and so is forking a session that has one unless you say what the forks get, --gpu l40s or --input '{"gpu":null}' for none. Anything that already has an L4 keeps it until it’s done.
  • Renders read saved files. A render reads a .blend from your org’s files, never a session’s unsaved scene. So save the scene, then download it: each file a download fetches is also copied to your org’s files as sessions/<session>/<path>, which is the path to render. Render one frame at low samples first and look at it before paying for the range.
  • A render’s cost is known before it runs. It renders the first frame to estimate the rest, and stops rather than pass --max-cost. Waiting running out never cancels a render, so don’t start it again: follow it with pch jobs status.
  • A long run keeps going. A run or a command can take up to an hour (--timeout-s). If the wait runs out first, pch exits 7 with the run’s id. That isn’t an error. Read how it ended with pch blender runs view rather than running it again.

One script over many files

To run one bpy script over many files or sets of parameters, up to 1,000 items, use the API: POST https://patch.gg/api/v1/blender/scripts, with a key that has compute. There’s no pch command or MCP tool for it yet. Each item runs in a fresh scene and gets args with its params, its file and out, a folder whose contents land in jobs/job_…/<index>/ in your org’s files. An item that fails doesn’t stop the others. Items are charged at a session’s price for their size and GPU, and max_cost is never passed. Follow the job as you would a render, with pch jobs status or job_status.

Credits

Everything is charged by the second, while it runs, at these prices in credits an hour:
  • Prices can change. pch blender prices gives today’s, and a running session’s own price is in its view (cost.per_hour).
  • Paused costs nothing. A session is charged only while it runs.
  • Starting needs credits in hand: 10 minutes of what everything you’re starting and running costs, together. A render first holds its estimate, plus a fifth.
  • Starter credits. Your own org gets 500, once: they’re there the first time you or your agent looks at its credits or starts something. A team org doesn’t get any, because its people’s own orgs did.
  • More credits. Buy more at patch.gg/credits, for your own org only, signed in to Patch on the site or in Patch Desktop: packs from 500 credits ($5) to 10,000 ($100), at $0.01 a credit, paid through Stripe. A key or an agent can’t buy them.
  • Whole credits. Your balance moves a whole credit at a time, and what a session or job cost is rounded to the nearest credit when it ends.
  • Where to see it. Your credits are at the top of your account menu, and usage → opens patch.gg/usage, which shows what they went on over the last 7, 30 or 90 days. pch credits shows the balance and every recent change. Each session and job shows what it’s cost (cost.spent), and your agent should tell you when it’s done.

Limits

Each org can have 16 sessions running at once, 1 of them with a GPU. Paused and stopped sessions don’t count, and one you pause or stop frees its place straight away. Past that, a start, resume, restore or fork starts nothing and answers session_limit_reached, saying how many are running and how many more would fit. For example: “<org> has 1 session with a GPU running, and can have 1 at once for now. Nothing was started: stop or pause one, or use one without a GPU, then try again. To run more at once, ask Patch.” Any call to a paused session in a full org gets the same answer, since it would resume it. A fork that wouldn’t all fit starts none. An org’s files hold 50 GiB: uploads, sessions’ copies and render outputs together. Past that, uploads and new renders answer storage_limit_reached. Nothing deletes files yet, so to go past either limit, ask Patch in Discord.

Good to know

  • Sessions pause themselves. After 5 minutes without a call, a session pauses and costs nothing. The next call that uses it (a run, a look, an inspect, an open, a save or a file transfer) resumes it in seconds. Reading a session, its logs or its checkpoints never resumes it. --idle-pause-minutes sets a longer wait, up to a day, and hold keeps it up while work goes on without calls.
  • What’s kept. A paused session keeps its files in /work and its saved scene for 30 days, and Python’s variables for 7 days (not on a GPU session). A resume says namespace: kept or fresh. Checkpoints are kept for 30 days. One is made when you ask, as a session pauses, and after every 10 minutes of use, keeping the newest 3 automatic ones.
  • Stopping is for good. A stopped session’s /work goes with it, so save and download what you want first. Its checkpoints can still be forked for 30 days. Files copied to your org’s files stay after it stops.
  • When credits run out, running sessions pause and renders stop. What a render had finished is kept. New starts are refused (insufficient_credits) until there are enough credits for 10 minutes.
  • A crash loses little. If a session’s machine stops unexpectedly, the session is left paused at its newest checkpoint, so at most about 10 minutes of work is lost. The next call resumes it and says what was lost.
  • There’s no window. Screenshots and most viewport operators don’t work. Your agent looks at the scene with look and works through bpy.data.
  • Files a session hands back are its own. A download leaves out hidden files, agent instruction files and git’s own files unless you name them by exact path. Treat what it fetches like any other download.