DEV Community: 加藤慧祐

Codex and Claude Code MCP setup for JANCTION Render, and the limits that are easy to miss

加藤慧祐 — Fri, 02 Oct 2026 14:02:24 +0000

JANCTION Render (https://render.janction.jp) renders AI-written scenes and existing .blend files on a cloud GPU. It is a separate product from SmartRender, JasmyLab's distributed-GPU platform.

Add https://render.janction.jp/mcp and an agent can render a Blender scene on a cloud GPU. As of 2026-10-02 the beta is free: no sign-up and no card. You need an MCP client that allows a custom remote server. The quota is 10 GPU-minutes per key per day and 20 per network. A job past that limit is rejected with HTTP 429 quota_exceeded and resets_at. It is not queued until the next day, and splitting the job does not increase the daily quota. Resubmit after 00:00 UTC (09:00 JST). One job may be at most 240 frames at 1080p.

This post is from JasmyLab, the operator of JANCTION Render. The service is a beta on one shared GPU, with no availability guarantee. The inference API on the same machine has priority.

Site: https://render.janction.jp
Repository: https://github.com/JasmyLab-JANCTION/janction-render

What this MCP is

It renders. It does not model the scene that is open in your desktop Blender. A local Blender MCP does that, and it does not require a discrete GPU: Cycles can render on a CPU. JANCTION Render accepts a .blend, a bpy script, or a 3D file (glTF, FBX, USD, OBJ, STL, PLY, Alembic), runs Blender on a datacenter NVIDIA GPU, and returns a preview, frames, or an MP4.

Default Blender is 5.0. Pass blender="5.2" when render_info or /v1/health lists 5.2. On 2026-10-02 the public health endpoint listed both. The default engine is Cycles. Final jobs can set engine='eevee'; each EEVEE job pays a shader-compile overhead, so short previews stay on Cycles.

Codex

codex mcp add janction-render --url https://render.janction.jp/mcp

Authentication is OAuth. The consent page creates a free key. If the client cannot open a browser, a raw API key from POST /v1/keys also works as Authorization: Bearer.

There is a plugin marketplace entry on the same GitHub repository (codex plugin marketplace add JasmyLab-JANCTION/janction-render). Marketplace install and a successful render are different checks. Confirm with render_info before you trust a render.

Prompt that matches the published sample:

Using JANCTION Render, build a glossy red cube rotating on a grey floor and show me a 4-frame preview.
If it looks right, call render_estimate, then render 24 frames at 1280x720 as an MP4.

Claude Code

claude mcp add --transport http janction-render https://render.janction.jp/mcp

Then /mcp and authenticate. The same prompt works. Claude.ai's custom connector is a separate path (Settings → Connectors) and depends on the plan. Team and enterprise admins can disable custom MCP servers. Do not treat "it works in Claude Code" as "it works in every Claude surface."

Setup pages:

A render, not a Blender session

The useful order is fixed:

scene_info reads cameras, frame range, and missing files without rendering.
render_preview returns 1–4 frames. The published 4-tile example (rotating cube, 640×360 tiles, 16 samples) was about 4 GPU seconds. The round trip that day was about 8 seconds. Those are different clocks.
render_estimate returns a duration and whether the job fits today's quota.
render_final renders frames and can join an MP4. render_download returns files or 24-hour links.

GPU seconds include Blender startup and scene load on the worker. They are not "GPU chip only," and they are not the time from your keypress to the file on disk. Queue wait is extra. Whether the upload is inside the round-trip number depends on the path; do not assume every published case includes it.

A 24-frame 1280×720 MP4 at 64 samples was about 58.7 GPU seconds, with a round trip around 65 seconds, on an NVIDIA RTX PRO 6000 Blackwell Max-Q Workstation Edition (96 GB). That scene is simple. Volumes and large textures will not scale the same way. Figures: https://render.janction.jp/benchmarks and https://render.janction.jp/benchmarks.json

What fails in ordinary use

A .blend saved in a newer Blender than the worker you selected.
Unpacked image textures. Pack them, or send them as assets. Missing textures render pink.
Asking for more than 240 frames or above 1920×1080 in one free-beta job (beta_limit). Split that job. Do not split in order to get more than 10 GPU-minutes today.
Custom add-ons. The worker is stock Blender 5.0 or 5.2 plus the bundled HDRI presets and standard importers.
Treating Colab, SheepIt, or Sceneplane as the same product. Colab's official FAQ does not promise a T4 or a 90-minute idle timeout. SheepIt has no MCP. Sceneplane's free tier, checked 2026-10-02, is 30 compute minutes per month and includes scene work, not a GPU-second quota. https://sceneplane.online/

Nothing is billed during this beta. Pages that mention 0.1 JPY per GPU second are describing a planned rate, not an invoice.

Primary pages

How to read a Blender cloud render benchmark: GPU seconds are not the round trip

加藤慧祐 — Fri, 02 Oct 2026 14:01:08 +0000

JANCTION Render (https://render.janction.jp) renders AI-written scenes and existing .blend files on a cloud GPU. It is a separate product from SmartRender, JasmyLab's distributed-GPU platform.

A 4-second Blender preview and a 4-second round trip are not the same claim. JANCTION Render publishes both, for a few simple scenes, and they answer different questions. This note is how to reproduce the published matrix and how not to quote it.

This post is from JasmyLab, which operates JANCTION Render. The numbers below are individual observations from production logs, not a speed guarantee and not a comparison against Colab, SheepIt, or another farm.

Machine-readable table: https://render.janction.jp/benchmarks.json
Human page: https://render.janction.jp/benchmarks

The two clocks

GPU seconds are worker run time. They include starting Blender and loading the scene. They are not "the GPU was busy for this many seconds" in a profiler sense, and they do not include time the job spent queued while the GPU was lent to something else.

Round trip is submission until the result is received. In the published cases the queue was empty. Input upload is not guaranteed to be inside that number for every case. Do not subtract GPU seconds from the round trip and call the remainder "upload," and do not add a guessed upload on top of GPU seconds.

Checked against the production description on 2026-10-02:

Example	What was rendered	GPU time	Round trip
4-frame preview	Rotating cube, four 640×360 tiles, 16 samples, scene lights	about 4 s	about 8 s
Short MP4	24 frames, 1280×720, 64 samples	about 58.7 s	about 65 s

GPU: NVIDIA RTX PRO 6000 Blackwell Max-Q Workstation Edition, 96 GB. Dates on the benchmark page are in UTC. The 24-frame case is from 2026-09-30 / 2026-10-01 logs.

What you can re-run

The matrix uses small scenes you can download, including https://render.janction.jp/samples/cube_scene.py. The page's command shape is:

janction-render render cube_scene.py --frames 1-24 --size 1280x720 --samples 64 --output png --wait

Those files reproduce the matrix scenes. They are not bit-identical to every historical Claude.ai transcript that produced a similar cube. If your re-run disagrees, keep your resolution, samples, frame count, engine, Blender version, and whether the queue was empty next to the number. Cycles is the default. EEVEE is available on final jobs and adds per-job shader compilation, so a one-frame EEVEE timing is a poor way to estimate a long EEVEE animation.

render_estimate is the number to use for a new scene. After that scene has been rendered once, later estimates can use its own history. The published "about 11 seconds" for one 1920×1080 frame at 128 samples is the estimator's baseline for a light scene, not a promise.

What the matrix seemed to say, and what it does not

On those simple scenes, moving from 32 to 128 samples added roughly ten percent, and a 100-frame run was about four times a 24-frame run. Per-frame time was dominated by fixed work: scene build, denoising, file write. About 2.4 seconds per 720p frame and about 5.2 seconds per 1080p frame showed up in that table.

That pattern is about those scenes. A volume, a large texture, or a shader that actually spends its time on samples will not follow it. The benchmark page says so. Quoting "samples are free, only resolution matters" without the scene is a misquote.

Free quota is a third clock

Beta quota is GPU seconds, defaulting in code to 600 per key per day and 1200 per network, resetting at 00:00 UTC. The 24-frame example above is about one GPU-minute, so several such clips fit in a day only while the scene stays that cheap. A heavier scene can exhaust the quota on the first final render. Crossing the quota returns 429 quota_exceeded and resets_at. The job is refused, not held. Splitting it does not mint a new daily budget.

Nothing is charged during the beta. A planned rate of 0.1 JPY per GPU second is labeled as planned on the benchmark page. It is not a bill.

Do not use these numbers against another service

There is no controlled Colab run in this dataset. Colab's own FAQ says GPU type, idle timeout, and lifetime vary, and that free notebooks run for at most 12 hours depending on availability. https://research.google.com/colaboratory/faq.html

There is no controlled SheepIt run either. SheepIt is free and has no API. A long animation there can finish sooner when volunteers pick up frames. That is a different system. https://www.sheepit-renderfarm.com/

Sceneplane's free plan, as published on its site on 2026-10-02, includes 30 compute minutes per month. Compute there includes scene building and export. It is not a GPU-second figure you can subtract from the table above. https://sceneplane.online/