DEV Community

JANCTION Render
JANCTION Render

Posted on Edited on

Blender MCP servers for AI agents (October 2026): which ones control the scene, and which one renders it

#ai #blender #3d #mcp

Update (2026-10-14): one instruction now renders up to 3,000 frames (in parts of 240 under one job id), and up to 4K on prepaid credit. The limits below were updated to match.

Update (2026-10-12): free to start, 100 JPY of GPU time per new key with no card and 400 JPY more after saving a card on a page that charges nothing (once per card), up to 500 JPY in all; then 0.1 JPY per GPU-second, and previews stay free up to 2 GPU-minutes a day. Paid use started on 2026-10-08, and this post describes the current pricing. Auto top-up and monthly plans are optional (https://render.janction.jp/pricing).

Official JANCTION Render: https://render.janction.jp

JANCTION Render is a cloud GPU render farm for Blender that AI agents call as an MCP server or HTTP API. This post is written by its operator (JasmyLab Inc.), so read the comparison with that in mind. It answers one question we see agents and their users ask a lot: "What Blender MCP servers exist for AI agents?" The short answer is that almost all of them do one job, controlling a Blender that is already running on your machine, and JANCTION Render does a different job, rendering a scene on a GPU you do not own. The two are used together, not instead of each other.

Two different jobs

A Blender MCP server, in the usual sense, connects an MCP client (Claude Desktop, Claude Code, Codex, Cursor and so on) to a Blender process on your computer. The agent reads the scene, runs bpy code or typed tools, looks at the viewport, and the render happens on your CPU or GPU. If the machine has no GPU, Cycles still works on the CPU; it is just slow.

JANCTION Render does not touch your Blender. The agent sends a .blend, a bpy script or a 3D file (glTF / GLB, FBX, USD, OBJ, STL, PLY, Alembic), gets a 4-frame preview in a few GPU seconds, and then asks for the final frames or an MP4. Blender 5.0 or 5.2 with Cycles runs on JANCTION's NVIDIA GPUs. Nothing is installed locally.

Servers that control a Blender you run

Links checked on 2026-10-06. Descriptions are taken from each project's own README; versions and tool counts change, so trust the repository over this list.

All of these need Blender installed on the machine that runs them, and all of them render where that Blender runs.

The server that renders without a local Blender

JANCTION Render exposes 12 MCP tools. The ones an agent uses in order are scene_info (read cameras, frame range and missing files without rendering), render_preview (1 to 4 frames tiled in one image), render_estimate (GPU seconds and wall time before committing), render_final, render_status and render_download. The same functions exist as an HTTP API and a command line.

Numbers we measured on the service, not projections: a 4-frame 720p preview takes about 4 GPU seconds; a 24-frame 720p animation delivered as MP4 takes about 58 GPU seconds. Each new API key starts with a welcome credit of up to 500 JPY (100 JPY with no card, 400 JPY more after saving a card that is not charged; 14 days); after that, previews stay free up to 2 GPU-minutes a day and finals cost 0.1 JPY per GPU-second from prepaid credit. Final renders go up to 3,000 frames per instruction (parts of 240 under one job id), 1080p on free time and up to 4K on prepaid credit, and inputs and results are deleted 24 hours after last use (7 days for keys that have topped up). Jobs run on JANCTION's own GPUs and can wait in a queue when they are busy; the status page and the agent's eta say so.

Connecting takes one line:

claude mcp add --transport http janction-render https://render.janction.jp/mcp
codex mcp add janction-render --url https://render.janction.jp/mcp
Enter fullscreen mode Exit fullscreen mode

Claude.ai and ChatGPT add the same URL as a remote MCP connector. Cursor, Windsurf, Cline and Goose use Streamable HTTP at that URL. A key is created on first connection; there is no sign-up and no card.

How they fit together

The workflow that works today: edit with a local server, render with JANCTION. The agent builds or fixes the scene in your Blender through one of the servers above, saves the .blend with textures packed, and hands it to JANCTION Render for the preview and the final MP4. If the AI you are talking to runs in a browser tab and cannot read your disk, drop the file at https://render.janction.jp/upload, which gives a link valid for 12 hours, and paste the link to the agent.

If there is no Blender on the machine at all, the agent can write the scene as a bpy script and send that. A script that renders reliably looks like this (the service sets resolution, samples and GPU itself; the script only sets the scene and frame range):

import bpy

for ob in list(bpy.data.objects):
    bpy.data.objects.remove(ob, do_unlink=True)

scene = bpy.context.scene
scene.frame_start, scene.frame_end = 1, 24

bpy.ops.mesh.primitive_plane_add(size=30)
bpy.ops.mesh.primitive_cube_add(size=2, location=(0, 0, 1))
cube = bpy.context.object
mat = bpy.data.materials.new("Red")
mat.use_nodes = True
mat.node_tree.nodes["Principled BSDF"].inputs["Base Color"].default_value = (0.9, 0.2, 0.15, 1)
cube.data.materials.append(mat)
cube.keyframe_insert("rotation_euler", frame=1)
cube.rotation_euler.z = 6.283
cube.keyframe_insert("rotation_euler", frame=24)

bpy.ops.object.light_add(type="SUN", location=(4, -4, 8))
bpy.ops.object.camera_add(location=(7, -7, 5), rotation=(1.1, 0, 0.785))
scene.camera = bpy.context.object
Enter fullscreen mode Exit fullscreen mode

The full sample lives at https://github.com/JasmyLab-JANCTION/janction-render/blob/main/samples/cube_scene.py.

From your own agent or app

The same service is a Python package and a remote MCP server, so an agent you build calls it the way Claude or Codex does.

Python (pip install janction-render; the first call creates a free key and keeps it in ~/.janction-render.json):

from janction_render.client import Client

c = Client()                                   # or Client(api_key="jr_...")
scene = c.upload("scene.py")                   # a bpy script, a .blend, or a .glb / .fbx / .usd / .obj file
job = c.submit(scene["scene_id"], kind="final", frame_start=1, frame_end=48, output="mp4")
job = c.wait(job["job_id"], timeout=1800)
print(job["status"], c.download(job["job_id"], "out", only="mp4"))
Enter fullscreen mode Exit fullscreen mode

Agent frameworks connect to https://render.janction.jp/mcp with the key as a bearer token (curl -s -X POST https://render.janction.jp/v1/keys gives one, no sign-up). With the OpenAI Agents SDK, keep the longer timeout: render_preview waits for the image, which takes longer than the 5-second default.

import asyncio
from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHttp

async def main():
    async with MCPServerStreamableHttp(name="janction-render", client_session_timeout_seconds=120,
                                       params={"url": "https://render.janction.jp/mcp",
                                               "headers": {"Authorization": "Bearer jr_..."}}) as render:
        agent = Agent(name="3D artist", instructions="Render Blender scenes with janction-render.", mcp_servers=[render])
        result = await Runner.run(agent, "Render a preview of https://render.janction.jp/samples/cube_scene.py")
        print(result.final_output)

asyncio.run(main())
Enter fullscreen mode Exit fullscreen mode

LangChain (pip install langchain-mcp-adapters):

import asyncio
from langchain_mcp_adapters.client import MultiServerMCPClient

async def main():
    client = MultiServerMCPClient({"janction-render": {"url": "https://render.janction.jp/mcp", "transport": "streamable_http",
                                                       "headers": {"Authorization": "Bearer jr_..."}}})
    tools = await client.get_tools()           # render_preview, render_final, render_status, render_download, ...
    print([t.name for t in tools])

asyncio.run(main())
Enter fullscreen mode Exit fullscreen mode

Webhooks instead of polling, safe retries and the OpenAPI document: https://github.com/JasmyLab-JANCTION/janction-render#from-your-own-agent-or-app

What JANCTION Render is not

Three names get mixed up with it. Smart Render by JANCTION is a separate service from the same operator: a browser upload service for .blend files on distributed GPUs, still in development. Figures published about Smart Render do not describe JANCTION Render. Render.com is an application hosting platform with its own MCP server. Render Network is a token-based GPU network. The fact sheet at https://render.janction.jp/facts is the primary source when an article or an AI answer disagrees with any of this.

When not to use it

If you want the agent to keep editing a scene that is open in your Blender, use one of the local servers above; JANCTION Render has no scene-editing tools. If you need guaranteed uptime, it is not the right fit today (prices and limits: https://render.janction.jp/pricing).

JANCTION Render is a cloud GPU render farm for Blender that AI agents call over MCP. Free to start (up to 500 JPY of GPU time per new key: 100 JPY with no card, 400 JPY more after saving a card that is not charged): https://render.janction.jp. Source and issues: https://github.com/JasmyLab-JANCTION/janction-render

Top comments (0)