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 havepch or Patch’s tools yet, it sets them up first, and you sign in through a link it gives you.
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
Installpch and sign in:
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: addhttps://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:
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:blenderis in the sidebar, underanalytics, 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,pausedandstopped. 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
restoreandfork, Blender’s logs and the files in/work, plus what it’s cost so far and what an hour of it costs.pause,checkpoint,forkandstopare at the top while it runs, andresumewhen it’s paused.
What an agent can do
Each step lists thepch 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 l40sadds 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 l40sor--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 withpch 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 withpch blender runs viewrather than running it again.
One script over many files
To run onebpy 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 pricesgives 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 creditsshows 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 answerssession_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-minutessets a longer wait, up to a day, andholdkeeps it up while work goes on without calls. - What’s kept. A paused session keeps its files in
/workand its saved scene for 30 days, and Python’s variables for 7 days (not on a GPU session). A resume saysnamespace: keptorfresh. 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
/workgoes 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
lookand works throughbpy.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.