Skip to content

Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.

feat(blender-mcp): add blender_optimize and orbiting multi-view renders

nirholas2b1e77e65c63
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f9edb511d..1445ac81b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,7 @@ Public history for [three.ws](https://three.ws), newest first. New pages come fr
- **A payment we cannot read now comes back with the price list, not a bare error**: When an agent pays one of our x402 endpoints and the payment header arrives mangled (truncated in transit, double-encoded, wrapped by a proxy), the answer used to be a plain 400 error with no prices in it, so the agent had nothing left to work from and no way to retry. Every rejected payment now returns the ordinary 402 with the full list of accepted rails, tokens and amounts attached, exactly as it does when a payment is simply missing. That is what the x402 spec and the OKX seller SDK both do, and it means a paying agent can always read the quote again and try once more. Only a real server fault answers without a quote. (`/docs/okx-marketplace`) `[fix, improvement]`
- **Blender tools now open three.ws avatars, which Blender alone cannot**: Most three.ws avatars are delivered in a compressed form that Blender flatly cannot read: point stock Blender at one and it refuses the file. That made the new Blender tools useless on exactly the models this platform produces. Compressed models are now unpacked automatically before Blender opens them, for both of the common compression schemes, with nothing extra to install and your original file left untouched. The answer tells you when it happened. `[fix, sdk]`
- **My Creations: one button that takes you back to everything you made**: A creator told us the making part was intuitive and the finding part was not: they built an agent, closed the tab, and had no obvious way back to it. There is now a My creations button in the header, and it opens a single page holding everything you have made, newest first: your agents, the 3D avatars saved to your account, and every model you forged, with Open, Edit and Copy link on each one. Signed out it still finds the models forged in this browser, so work made before you had an account is not lost. Filter by type, search by name or prompt, and hover any card to spin it in 3D. The create wizard and the Forge now point here too, so you are told where your work lives at the moment you make it. (`/mine`) `[feature, improvement]`
+- **One command makes a 3D model small enough to ship, and shows you all four sides**: Getting a model down to a size a web page can load used to mean writing a Blender script by hand every time: cut the polygon count, shrink the textures, throw away what nothing uses, compress the result. That is now a single request with a budget, and it answers with an honest before and after, so you can see what the size actually cost you in detail. On a test model it went from 1.3 MB to 282 KB. Previews can also orbit the model now: ask for four angles and you get four pictures from one pass, which is what tells you whether the back of a model was ever finished, or whether a texture only looks right from the front. `[feature, sdk]`
- **Point an AI agent at the Blender on your own machine**: A new MCP server drives the Blender you already have installed, with no GUI open and no add-on to install first. An assistant can now read a 3D file and tell you what is actually in it (objects, triangle counts, materials, bones, animations, real-world size), convert between GLB, glTF, FBX, OBJ, STL, PLY, Collada, Alembic, USD and .blend in either direction, render a preview image of a bare asset file that arrives with no camera or lighting of its own, and run a Blender Python script to do the things no single tool covers, like halving a mesh's triangle count and exporting the result in one step. It also reaches back into three.ws: describe something in a sentence and the free text-to-3D lane generates it and opens it in Blender. Blender runs in the background, one process per request, so it works the same on a laptop, a server, or in CI. `[feature, sdk]`
- **Shared avatar and agent links now show a real page to Google, not a loading spinner**: Search engines were shown a different version of every /avatars/... and /agents/... page than people were, and that version had nothing on it: the name and description were hidden in a fallback block that a crawler removes before reading, the rest was a spinner, and the last line of the page sent the crawler straight back to the URL it was already on. Tens of thousands of avatar and agent pages therefore looked identical to Google and were filed as duplicates instead of being listed. Crawlers now get the same content a visitor sees: the name, the description, the rendered card, the creator, the tags, the skills, the on-chain identity, and links onward into the gallery and the directory. A link to an avatar or agent that no longer exists now says so honestly instead of quietly bouncing to a listing page, an id that belongs to the other side of the platform redirects to where it actually lives, and a private agent is no longer readable by anything sending a crawler's name. Signed-in surfaces were also unblocked in robots.txt so their existing no-index instruction can finally be read and obeyed. `[fix, infra]`
- **The AgenC task embed now loads even when it is inlined or served from a blob**: The <three-ws-agent> element that shows a 3D avatar reacting to an on-chain AgenC task resolves its mesh decoder relative to its own script address. A copy that had been pasted inline, bundled, or loaded from a blob: or data: URL has no address to resolve against, and the element failed to register before it drew anything. It now falls back to the decoder on three.ws in that case and keeps the same-origin path everywhere else, so the embed works wherever the snippet ends up. (`/agenc/embodied`) `[fix]`
diff --git a/data/changelog.json b/data/changelog.json
index d1040e141..7c6604691 100644
--- a/data/changelog.json
+++ b/data/changelog.json
@@ -26833,6 +26833,15 @@
"fix",
"sdk"
]
+ },
+ {
+ "date": "2026-09-07",
+ "title": "One command makes a 3D model small enough to ship, and shows you all four sides",
+ "summary": "Getting a model down to a size a web page can load used to mean writing a Blender script by hand every time: cut the polygon count, shrink the textures, throw away what nothing uses, compress the result. That is now a single request with a budget, and it answers with an honest before and after, so you can see what the size actually cost you in detail. On a test model it went from 1.3 MB to 282 KB. Previews can also orbit the model now: ask for four angles and you get four pictures from one pass, which is what tells you whether the back of a model was ever finished, or whether a texture only looks right from the front.",
+ "tags": [
+ "feature",
+ "sdk"
+ ]
}
]
}
diff --git a/docs/blender-mcp.md b/docs/blender-mcp.md
index 00d4d80f1..854a9af7a 100644
--- a/docs/blender-mcp.md
+++ b/docs/blender-mcp.md
@@ -13,7 +13,8 @@ That makes it the piece that sits under the three.ws pipeline rather than beside
| Know what is actually inside a file a client sent you | `blender_scene_info` |
| Turn an FBX or a USD into a web-ready GLB (or the reverse) | `blender_convert` |
| See a model without opening anything | `blender_render` |
-| Do something no single tool covers: decimate, join, rename bones, bake | `blender_run_python` |
+| Make a model small enough to ship, and see what it cost | `blender_optimize` |
+| Do something no single tool covers: join, rename bones, bake | `blender_run_python` |
| Generate an asset from a sentence and open it | `blender_forge_import` |
| Find out why one of the above failed | `blender_info` |
@@ -105,6 +106,26 @@ Both sides accept `.glb`, `.gltf`, `.fbx`, `.obj`, `.stl`, `.ply`, `.dae`, `.abc
blender_convert { "input": "character.fbx", "output": "character.glb", "scale": 0.01 }
```
+### `blender_optimize`
+
+| Argument | Type | Notes |
+|---|---|---|
+| `input` | string, required | Model to optimize. |
+| `output` | string | Destination. The extension picks the format. Defaults to a `.glb` in the workdir. |
+| `max_triangles` | integer | Triangle budget for the whole scene. Omit to leave geometry alone. |
+| `max_texture_px` | integer | Longest edge any texture may keep. Omit to leave textures alone. |
+| `compress` | enum | `meshopt` (default), `draco`, or `none`. Applies to glTF output only. |
+
+The delivery pass, in one call. Decimation is collapse-based and applies **one ratio across the whole scene**, so meshes keep their relative density: a per-object budget is what flattens a face while leaving a wall at full resolution. Textures are scaled and repacked, unreferenced datablocks are dropped, and the mesh streams are compressed on the way out.
+
+Compression runs outside Blender because Blender's exporter offers Draco only, and only on builds shipping the library, while meshopt is what the three.ws runtime and every major web viewer decode.
+
+```
+blender_optimize { "input": "character.glb", "output": "character-web.glb", "max_triangles": 30000, "max_texture_px": 1024 }
+```
+
+The response carries `before` and `after` counts, `saved_bytes`, `saved_percent`, and a `steps` array saying what each stage did, so the trade is visible instead of guessed. Vertex groups survive decimation, but check a heavily decimated skinned mesh with `blender_render` before shipping it.
+
### `blender_render`
| Argument | Type | Notes |
@@ -115,8 +136,11 @@ blender_convert { "input": "character.fbx", "output": "character.glb", "scale":
| `samples` | integer | Default `32`, enough for a preview. |
| `resolution` | `[width, height]` | Default `[960, 960]`. |
| `transparent` | boolean | Transparent background instead of the world. Default `false`. |
+| `views` | integer | How many angles to render, orbiting the model, 1 to 6. Default 1. |
| `inline_image` | boolean | Return the image inline so the assistant can see it. Default `true`. |
+Asking for several `views` orbits the model and renders every angle in the **same** Blender launch, one import for the whole set, and returns them all inline. Four views is what answers questions a single angle hides: whether the back is modelled at all, whether a texture only reads from the front. A multi-view set always orbits its own camera, so an authored camera is honoured only when `views` is 1.
+
The rendered image comes back **inline** as an MCP image block, downscaled to fit the caller's context, while the full-resolution PNG is written to disk. That is what makes a see-and-fix loop possible in one call, and it is the only way the render is reachable at all from a client with no filesystem access.
An asset file usually carries no camera and no lights, which is why rendering one straight out of a converter normally produces a black square. This tool fills both in: it creates a camera and frames it to the geometry's bounding sphere, and adds a key light and a lit world. A scene that already has its own camera and lighting is rendered exactly as authored, and the response says which of the two happened (`camera_created`, `lights_created`).
diff --git a/packages/blender-mcp/README.md b/packages/blender-mcp/README.md
index c0bd68b9d..b738227bb 100644
--- a/packages/blender-mcp/README.md
+++ b/packages/blender-mcp/README.md
@@ -68,7 +68,8 @@ Add `"env": { "BLENDER_PATH": "/path/to/blender" }` if Blender is not on `PATH`.
| `blender_info` | Reports the Blender being driven: path, version, bundled Python, usable render engines, and the import/export formats this build actually supports. Read-only. |
| `blender_scene_info` | Opens a 3D file and describes it: objects with types, parents, dimensions and modifiers; evaluated triangle and vertex counts; materials; a texture inventory with each image's resolution and byte size; armature bone names; animation actions with frame ranges; world-space bounds. Read-only. |
| `blender_convert` | Imports one format and exports another, chosen by the file extensions. Applies modifiers by default and can bake in a uniform unit scale. The exact format list depends on the build (some Linux packages ship without USD, Collada, or Alembic), and `blender_info` reports what yours actually has. |
-| `blender_render` | Renders a still PNG and returns it **inline**, so the assistant can actually see the model in one call even with no filesystem access. If the file has no camera, one is created and framed to the model's bounding sphere; if it has no light, a key light and a lit world are added. A scene that already has its own camera and lighting renders as authored. |
+| `blender_optimize` | The delivery pass in one call: decimate to a triangle budget, scale oversized textures, purge unreferenced datablocks, and compress the mesh streams with meshopt or Draco. Reports before and after triangles, texture bytes and file size. |
+| `blender_render` | Renders a still PNG and returns it **inline**, so the assistant can actually see the model in one call even with no filesystem access. Ask for several views and it orbits the model, every angle in the same launch. If the file has no camera, one is created and framed to the model's bounding sphere; if it has no light, a key light and a lit world are added. A scene that already has its own camera and lighting renders as authored. |
| `blender_run_python` | Runs a `bpy` script against a scene, optionally opening a file first and exporting the result afterwards. The escape hatch for anything the other tools do not cover. |
| `blender_forge_import` | Generates a model from a text prompt on the public three.ws Forge pipeline and brings it into Blender, converting on the way in if the output asks for another format. The default image lane is free. |
@@ -83,6 +84,19 @@ blender_scene_info { "input": "~/assets/character.fbx" }
→ 4 meshes, 41,208 triangles, 1 armature (67 bones), 3 actions, bounds 1.78m tall
```
+Make a model shippable and see what it cost:
+
+```
+blender_optimize { "input": "character.glb", "output": "character-web.glb", "max_triangles": 30000, "max_texture_px": 1024 }
+→ 4.1 MB to 780 KB (81% saved): 96,412 to 30,000 triangles, textures 2048 to 1024, meshopt compressed
+```
+
+Look at it from four sides at once:
+
+```
+blender_render { "input": "character-web.glb", "views": 4 }
+```
+
Convert a client's FBX into a web-ready GLB, in metres:
```
diff --git a/packages/blender-mcp/package.json b/packages/blender-mcp/package.json
index 1ee6924c2..c4b044df6 100644
--- a/packages/blender-mcp/package.json
+++ b/packages/blender-mcp/package.json
@@ -1,6 +1,6 @@
{
"name": "@three-ws/blender-mcp",
- "version": "0.3.0",
+ "version": "0.4.0",
"mcpName": "io.github.nirholas/blender-mcp",
"description": "Drive the Blender on your machine from any AI agent, headless. Inspect a 3D file, convert between GLB/glTF/FBX/OBJ/STL/PLY/DAE/USD/Alembic/.blend, render a preview that comes back inline so the assistant can see it, run a bpy script against a scene, and generate a model from a text prompt on the free three.ws Forge lane. Meshopt- and Draco-compressed glTF is decoded automatically. No GUI, no add-on to install, no key.",
"type": "module",
@@ -20,6 +20,7 @@
"ai-agent",
"blender",
"bpy",
+ "decimate",
"draco",
"fbx",
"glb",
@@ -28,6 +29,7 @@
"mcp",
"meshopt",
"model-context-protocol",
+ "optimization",
"render",
"three.ws",
"usd"
diff --git a/packages/blender-mcp/server.json b/packages/blender-mcp/server.json
index 256d26dc9..3942bdc17 100644
--- a/packages/blender-mcp/server.json
+++ b/packages/blender-mcp/server.json
@@ -18,12 +18,12 @@
"source": "github",
"subfolder": "packages/blender-mcp"
},
- "version": "0.3.0",
+ "version": "0.4.0",
"packages": [
{
"registryType": "npm",
"identifier": "@three-ws/blender-mcp",
- "version": "0.3.0",
+ "version": "0.4.0",
"runtimeHint": "npx",
"transport": {
"type": "stdio"
diff --git a/packages/blender-mcp/src/index.js b/packages/blender-mcp/src/index.js
index a36636fa5..8973908a0 100644
--- a/packages/blender-mcp/src/index.js
+++ b/packages/blender-mcp/src/index.js
@@ -5,6 +5,7 @@
// • blender_info: what this Blender build is and can do
// • blender_scene_info: read a 3D file and describe what is inside it
// • blender_convert: import one format, export another
+// • blender_optimize: decimate, resize textures, compress for delivery
// • blender_render: render a still preview, auto-framed and auto-lit
// • blender_run_python: run a bpy script against a scene
// • blender_forge_import: three.ws text-to-3D, brought into Blender
@@ -30,6 +31,7 @@ import { ALLOW_PYTHON } from './config.js';
import { def as blenderInfo } from './tools/info.js';
import { def as sceneInfo } from './tools/scene-info.js';
import { def as convert } from './tools/convert.js';
+import { def as optimize } from './tools/optimize.js';
import { def as render } from './tools/render.js';
import { def as runPython } from './tools/run-python.js';
import { def as forgeImport } from './tools/forge-import.js';
@@ -41,7 +43,7 @@ const { version: PKG_VERSION } = require('../package.json');
// blender_run_python executes caller-supplied code. It is advertised by default
// because scripted scene edits are most of what an agent needs Blender for, and
// withdrawn entirely when BLENDER_MCP_ALLOW_PYTHON=0.
-export const TOOLS = [blenderInfo, sceneInfo, convert, render, forgeImport, ...(ALLOW_PYTHON ? [runPython] : [])];
+export const TOOLS = [blenderInfo, sceneInfo, convert, optimize, render, forgeImport, ...(ALLOW_PYTHON ? [runPython] : [])];
/**
* Construct a fully-registered McpServer without connecting a transport.
@@ -60,7 +62,8 @@ export function buildServer() {
'fails. blender_scene_info opens a 3D file and describes it (objects, evaluated triangle counts, ' +
'materials, armature bones, animations, world bounds). blender_convert bridges formats in both ' +
'directions (.glb .gltf .fbx .obj .stl .ply .dae .abc .usd .x3d .blend), applying modifiers and an ' +
- 'optional unit scale. blender_render produces a still PNG, adding a framed camera and a key light when ' +
+ 'optional unit scale. blender_optimize is the delivery pass: a triangle budget, a texture ceiling, a purge ' +
+ 'and meshopt compression in one call, with an honest before/after. blender_render produces a still PNG, adding a framed camera and a key light when ' +
'the file has none, so a bare asset previews with no setup. blender_run_python runs a bpy script for ' +
'edits the other tools do not cover and can export the result in the same call. blender_forge_import ' +
'generates a model from a text prompt on the free public three.ws Forge lane and brings it in. Blender ' +
diff --git a/packages/blender-mcp/src/lib/gltf.js b/packages/blender-mcp/src/lib/gltf.js
index 6b99b025a..f92afc23f 100644
--- a/packages/blender-mcp/src/lib/gltf.js
+++ b/packages/blender-mcp/src/lib/gltf.js
@@ -96,3 +96,45 @@ export async function decodeForBlender(inputPath, scratchDir) {
await writeFile(output, Buffer.from(await io.writeBinary(document)));
return { path: output, decoded: compression };
}
+
+/**
+ * Re-encode a GLB with a mesh compression extension, in place.
+ *
+ * This is the last step of a delivery pass: meshopt typically halves what the
+ * exporter wrote, and every runtime that matters (three.js, model-viewer,
+ * Babylon) decodes it. It runs here rather than in Blender because Blender's
+ * exporter offers Draco only, and only on builds that ship the library.
+ *
+ * @param {string} glbPath File to rewrite.
+ * @param {'meshopt'|'draco'} method
+ * @returns {Promise<{method: string, before_bytes: number, after_bytes: number}>}
+ */
+export async function compressGlb(glbPath, method) {
+ const before = (await readFile(glbPath)).length;
+ const [{ NodeIO }, extensions, meshopt, draco] = await Promise.all([
+ import('@gltf-transform/core'),
+ import('@gltf-transform/extensions'),
+ import('meshoptimizer'),
+ import('draco3dgltf'),
+ ]);
+
+ await meshopt.MeshoptEncoder.ready;
+ const io = new NodeIO().registerExtensions(extensions.ALL_EXTENSIONS).registerDependencies({
+ 'meshopt.decoder': meshopt.MeshoptDecoder,
+ 'meshopt.encoder': meshopt.MeshoptEncoder,
+ 'draco3d.decoder': await draco.default.createDecoderModule(),
+ 'draco3d.encoder': await draco.default.createEncoderModule(),
+ });
+
+ const document = await io.read(glbPath);
+ if (method === 'draco') {
+ document.createExtension(extensions.KHRDracoMeshCompression).setRequired(true);
+ } else {
+ document
+ .createExtension(extensions.EXTMeshoptCompression)
+ .setRequired(true)
+ .setEncoderOptions({ method: extensions.EXTMeshoptCompression.EncoderMethod.QUANTIZE });
+ }
+ await io.write(glbPath, document);
+ return { method, before_bytes: before, after_bytes: (await readFile(glbPath)).length };
+}
diff --git a/packages/blender-mcp/src/py/runner.py b/packages/blender-mcp/src/py/runner.py
index 34da33ec0..11acb018f 100644
--- a/packages/blender-mcp/src/py/runner.py
+++ b/packages/blender-mcp/src/py/runner.py
@@ -357,6 +357,88 @@ def op_convert(job):
}
+def decimate_to_budget(max_triangles):
+ """Collapse-decimate every mesh proportionally to land under a triangle budget.
+
+ One ratio across the whole scene rather than per object: decimating each
+ mesh to the same ratio keeps their relative density, which is what stops a
+ budget pass from flattening a face while leaving a wall at full resolution.
+ """
+ depsgraph = bpy.context.evaluated_depsgraph_get()
+ meshes = mesh_objects()
+ before = sum(triangle_count(obj, depsgraph)[0] for obj in meshes)
+ if not meshes or before <= max_triangles:
+ return {"step": "decimate", "skipped": "already within budget", "triangles": before}
+
+ ratio = max(max_triangles / float(before), 0.005)
+ for obj in meshes:
+ modifier = obj.modifiers.new("three_ws_budget", "DECIMATE")
+ modifier.decimate_type = "COLLAPSE"
+ modifier.ratio = ratio
+ modifier.use_collapse_triangulate = True
+
+ bpy.context.view_layer.update()
+ depsgraph = bpy.context.evaluated_depsgraph_get()
+ after = sum(triangle_count(obj, depsgraph)[0] for obj in meshes)
+ return {"step": "decimate", "ratio": round(ratio, 5), "triangles_before": before, "triangles_after": after}
+
+
+def resize_textures(max_px):
+ """Scale every image whose longest edge exceeds the budget, in place.
+
+ Texture data is usually the larger half of a delivered asset, so this is
+ where the bytes actually are. Scaled images are repacked so the exporter
+ writes the smaller pixels rather than re-reading the original file.
+ """
+ resized = []
+ for image in bpy.data.images:
+ width, height = image.size
+ if not width or not height or max(width, height) <= max_px:
+ continue
+ ratio = max_px / float(max(width, height))
+ target = (max(int(width * ratio), 1), max(int(height * ratio), 1))
+ image.scale(*target)
+ if image.packed_file is not None:
+ image.pack()
+ resized.append({"name": image.name, "from": [width, height], "to": list(target)})
+ return {"step": "resize_textures", "resized": resized}
+
+
+def purge_orphans():
+ """Drop datablocks nothing references, which importers leave behind."""
+ removed = bpy.data.orphans_purge(do_local_ids=True, do_linked_ids=True, do_recursive=True)
+ return {"step": "purge", "datablocks_removed": removed}
+
+
+def op_optimize(job):
+ load_input(job["input"])
+ before = scene_summary(include_objects=False)
+ steps = []
+
+ max_triangles = job.get("max_triangles")
+ if max_triangles:
+ steps.append(decimate_to_budget(int(max_triangles)))
+
+ max_texture_px = job.get("max_texture_px")
+ if max_texture_px:
+ steps.append(resize_textures(int(max_texture_px)))
+
+ steps.append(purge_orphans())
+
+ output = export_to(job["output"], apply_modifiers=True)
+ after = scene_summary(include_objects=False)
+ return {
+ "input": os.path.abspath(job["input"]),
+ "output": output,
+ "output_bytes": os.path.getsize(output),
+ "input_bytes": os.path.getsize(os.path.abspath(job["input"])),
+ "before": before["counts"],
+ "after": after["counts"],
+ "steps": steps,
+ "textures": after.get("textures", []),
+ }
+
+
# Engines worth probing for, best first. The static RNA enum is not a reliable
# list: on some distro builds Cycles is assignable while absent from the enum,
# so capability is decided by whether the assignment actually takes.
@@ -509,6 +591,41 @@ def write_inline_preview(rendered_path, max_px):
bpy.data.images.remove(image)
+def orbit_camera(scene, target_objects, index, total):
+ """Place a camera on an orbit around the model and aim it at the centre.
+
+ Several angles answer a question one angle cannot: whether the back of a
+ model is modelled at all, whether a texture is only right from the front.
+ Rendering them in this one process costs one Blender start and one import
+ for the whole set instead of one of each per view.
+ """
+ bounds = world_bounds(target_objects)
+ camera = scene.camera
+ if camera is None or camera.name != "three_ws_camera":
+ camera_data = bpy.data.cameras.new("three_ws_camera")
+ camera = bpy.data.objects.new("three_ws_camera", camera_data)
+ scene.collection.objects.link(camera)
+ scene.camera = camera
+
+ # Start at the same three-quarter view a single render uses, so view 1 of a
+ # set is the same image a views=1 call would have produced.
+ base = math.atan2(-1.35, 1.0)
+ angle = base + (2.0 * math.pi * index) / total
+ if bounds is None:
+ center = Vector((0.0, 0.0, 0.0))
+ distance = 6.0
+ else:
+ _lo, _hi, center, radius = bounds
+ radius = max(radius, 1e-4)
+ distance = (radius / math.sin(camera.data.angle / 2.0)) * 1.05
+ camera.data.clip_start = max(distance / 1000.0, 1e-4)
+ camera.data.clip_end = distance * 10.0
+ direction = Vector((math.cos(angle), math.sin(angle), 0.62)).normalized()
+ camera.location = center + direction * distance
+ camera.rotation_euler = (center - camera.location).to_track_quat("-Z", "Y").to_euler()
+ return camera
+
+
def op_render(job):
load_input(job["input"])
scene = bpy.context.scene
@@ -531,28 +648,57 @@ def op_render(job):
scene.render.image_settings.color_mode = "RGBA" if job.get("transparent", False) else "RGB"
scene.render.film_transparent = bool(job.get("transparent", False))
- camera, camera_added = ensure_camera(scene, mesh_objects())
+ views = max(int(job.get("views", 1)), 1)
lights_added = ensure_lighting(scene)
output = os.path.abspath(job["output"])
parent = os.path.dirname(output)
if parent:
os.makedirs(parent, exist_ok=True)
- scene.render.filepath = output
- denoised = render_still(scene)
- if not os.path.isfile(output):
- raise JobError(f"Blender rendered but wrote no image at {output}", code="render_failed")
- preview = write_inline_preview(output, int(job.get("inline_max_px", 0)))
+
+ if views == 1:
+ camera, camera_added = ensure_camera(scene, mesh_objects())
+ targets = [(output, camera)]
+ else:
+ # A multi-view set always orbits its own camera: an authored camera
+ # frames one composition, which is not what a set of angles is for.
+ camera_added = True
+ stem, ext = os.path.splitext(output)
+ targets = []
+ for index in range(views):
+ camera = orbit_camera(scene, mesh_objects(), index, views)
+ targets.append((f"{stem}-{index + 1:02d}{ext}", camera))
+
+ inline_max_px = int(job.get("inline_max_px", 0))
+ outputs = []
+ previews = []
+ denoised = False
+ for index, (path_for_view, _camera) in enumerate(targets):
+ if views > 1:
+ orbit_camera(scene, mesh_objects(), index, views)
+ scene.render.filepath = path_for_view
+ denoised = render_still(scene)
+ if not os.path.isfile(path_for_view):
+ raise JobError(f"Blender rendered but wrote no image at {path_for_view}", code="render_failed")
+ outputs.append(path_for_view)
+ preview_for_view = write_inline_preview(path_for_view, inline_max_px)
+ if preview_for_view:
+ previews.append(preview_for_view)
+
+ preview = previews[0] if previews else None
return {
"input": os.path.abspath(job["input"]),
- "output": output,
- "output_bytes": os.path.getsize(output),
+ "output": outputs[0],
+ "outputs": outputs,
+ "output_bytes": os.path.getsize(outputs[0]),
+ "views": views,
"preview": preview,
+ "previews": previews,
"preview_bytes": os.path.getsize(preview) if preview else None,
"engine": engine,
"samples": samples,
"resolution": [scene.render.resolution_x, scene.render.resolution_y],
- "camera": camera.name,
+ "camera": scene.camera.name if scene.camera else None,
"denoised": denoised,
"camera_created": camera_added,
"lights_created": lights_added,
@@ -597,6 +743,7 @@ def op_probe(job):
OPS = {
"probe": op_probe,
+ "optimize": op_optimize,
"scene_info": op_scene_info,
"convert": op_convert,
"render": op_render,
diff --git a/packages/blender-mcp/src/tools/optimize.js b/packages/blender-mcp/src/tools/optimize.js
new file mode 100644
index 000000000..395e42c34
--- /dev/null
+++ b/packages/blender-mcp/src/tools/optimize.js
@@ -0,0 +1,87 @@
+// `blender_optimize`: make a model small enough to ship.
+//
+// This is the delivery pass three.ws runs constantly, and until now it took a
+// hand-written bpy script every time: decimate to a triangle budget, pull
+// oversized textures down, drop the datablocks importers leave behind, then
+// compress the mesh streams on the way out. Doing it in one call also means the
+// caller gets one honest before/after, rather than assembling it from four.
+//
+// Compression happens outside Blender because its exporter offers Draco only,
+// and only on builds shipping the library, while meshopt is what the three.ws
+// runtime and every major web viewer expect.
+
+import { z } from 'zod';
+
+import { runJob } from '../lib/blender.js';
+import { compressGlb } from '../lib/gltf.js';
+import { resolveInput, resolveOutput } from '../lib/paths.js';
+
+export const def = {
+ name: 'blender_optimize',
+ title: 'Shrink a 3D model for delivery',
+ annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+ description:
+ 'Make a model web-ready in one call: decimate every mesh proportionally to hit a triangle budget, scale ' +
+ 'oversized textures down, purge datablocks nothing references, and compress the mesh streams with meshopt ' +
+ '(or Draco) on the way out. Returns before and after triangle counts, texture bytes and file size, plus what ' +
+ 'each step did, so the trade is visible rather than guessed. The input file is never modified. Decimation ' +
+ 'is collapse-based and preserves vertex groups, but a heavily decimated skinned mesh should be checked with ' +
+ 'blender_render before shipping.',
+ inputSchema: {
+ input: z.string().min(1).describe('Path to the model to optimize.'),
+ output: z
+ .string()
+ .optional()
+ .describe('Destination. The extension picks the format. Defaults to a .glb in the server workdir.'),
+ max_triangles: z
+ .number()
+ .int()
+ .min(4)
+ .optional()
+ .describe('Triangle budget for the whole scene. Omit to leave geometry untouched.'),
+ max_texture_px: z
+ .number()
+ .int()
+ .min(16)
+ .max(8192)
+ .optional()
+ .describe('Longest edge any texture may keep, e.g. 1024. Omit to leave textures untouched.'),
+ compress: z
+ .enum(['meshopt', 'draco', 'none'])
+ .optional()
+ .describe(
+ 'Mesh compression for a .glb/.gltf output. "meshopt" (default) is what the three.ws runtime and every ' +
+ 'major web viewer decode. Ignored for other formats.',
+ ),
+ },
+ async handler(args) {
+ const input = await resolveInput(args?.input);
+ const output = await resolveOutput(args?.output, input, '.glb');
+ const payload = await runJob({
+ op: 'optimize',
+ input,
+ output,
+ max_triangles: args?.max_triangles,
+ max_texture_px: args?.max_texture_px,
+ });
+
+ const method = args?.compress ?? 'meshopt';
+ const steps = [...payload.steps];
+ let outputBytes = payload.output_bytes;
+ if (method !== 'none' && /\.(glb|gltf)$/i.test(output)) {
+ const compressed = await compressGlb(output, method);
+ steps.push({ step: 'compress', ...compressed });
+ outputBytes = compressed.after_bytes;
+ }
+
+ const saved = payload.input_bytes - outputBytes;
+ return {
+ ...payload,
+ ok: true,
+ steps,
+ output_bytes: outputBytes,
+ saved_bytes: saved,
+ saved_percent: payload.input_bytes ? Math.round((saved / payload.input_bytes) * 1000) / 10 : 0,
+ };
+ },
+};
diff --git a/packages/blender-mcp/src/tools/render.js b/packages/blender-mcp/src/tools/render.js
index 7b6cccf3b..19065f49f 100644
--- a/packages/blender-mcp/src/tools/render.js
+++ b/packages/blender-mcp/src/tools/render.js
@@ -27,7 +27,8 @@ export const def = {
'world are added, so a bare asset file renders as a usable preview with no setup. A scene that already has ' +
'its own camera and lighting is rendered as authored. The rendered image is returned INLINE alongside the ' +
'JSON, so you can actually look at the model in this one call without needing filesystem access, while the ' +
- 'full-resolution PNG is written to disk. Use it to see a model, check a conversion, or produce a thumbnail.',
+ 'full-resolution PNG is written to disk. Ask for several views and it orbits the model, rendering every angle ' +
+ 'in the same Blender launch. Use it to see a model, check a conversion, or produce a thumbnail.',
inputSchema: {
input: z.string().min(1).describe('Path to the 3D file to render.'),
output: z.string().optional().describe('Destination PNG path. Defaults to a .png in the server workdir.'),
@@ -45,6 +46,17 @@ export const def = {
.optional()
.describe('Output size as [width, height]. Default [960, 960].'),
transparent: z.boolean().optional().describe('Render with a transparent background instead of the world. Default false.'),
+ views: z
+ .number()
+ .int()
+ .min(1)
+ .max(6)
+ .optional()
+ .describe(
+ 'How many angles to render, orbiting the model, all in one Blender launch and all returned inline. ' +
+ 'Default 1. Use 4 to see whether the back of a model is modelled at all. A set always orbits its own ' +
+ 'camera, so an authored camera is only honoured when views is 1.',
+ ),
inline_image: z
.boolean()
.optional()
@@ -61,31 +73,46 @@ export const def = {
samples: args?.samples ?? 32,
resolution: args?.resolution ?? [960, 960],
transparent: args?.transparent === true,
+ views: args?.views ?? 1,
inline_max_px: args?.inline_image === false ? 0 : INLINE_IMAGE_MAX_PX,
});
return { ...payload, ok: true, inline_image: args?.inline_image !== false };
},
/**
- * Hand the rendered image back as an MCP image block.
+ * Hand every rendered view back as an MCP image block.
*
- * The scaled copy is read and then deleted: it exists only to travel in this
- * response, and leaving it beside the real output would be litter the caller
- * has to reason about. An image too large to inline is reported in the JSON
- * rather than silently dropped, so the caller knows to read the file.
+ * Scaled copies exist only to travel in this response, so they are read and
+ * then deleted; leaving them beside the real outputs would be litter the
+ * caller has to reason about. Images too large to inline are reported in the
+ * JSON rather than silently dropped, so the caller knows to read the files.
*/
async attachments(result) {
if (!result?.inline_image) return [];
- const path = result.preview || result.output;
- const bytes = result.preview ? result.preview_bytes : result.output_bytes;
- if (!path || !bytes) return [];
- if (bytes > INLINE_IMAGE_MAX_BYTES) {
- result.inline_image_skipped = `the image is ${bytes} bytes, over the ${INLINE_IMAGE_MAX_BYTES} inline limit; read it from ${result.output}`;
- if (result.preview) await rm(path, { force: true });
- return [];
+ const outputs = result.outputs || (result.output ? [result.output] : []);
+ const previews = result.previews || [];
+ const blocks = [];
+ let budget = INLINE_IMAGE_MAX_BYTES;
+
+ for (let index = 0; index < outputs.length; index += 1) {
+ const preview = previews[index];
+ const source = preview || outputs[index];
+ let data;
+ try {
+ data = await readFile(source);
+ } catch {
+ continue;
+ }
+ if (preview) await rm(preview, { force: true });
+ if (data.length > budget) {
+ result.inline_image_skipped =
+ `${outputs.length - blocks.length} view(s) exceeded the ${INLINE_IMAGE_MAX_BYTES} byte inline budget; ` +
+ `read them from ${outputs.slice(blocks.length).join(', ')}`;
+ break;
+ }
+ budget -= data.length;
+ blocks.push({ type: 'image', data: data.toString('base64'), mimeType: 'image/png' });
}
- const data = await readFile(path);
- if (result.preview) await rm(path, { force: true });
- return [{ type: 'image', data: data.toString('base64'), mimeType: 'image/png' }];
+ return blocks;
},
};
diff --git a/packages/blender-mcp/test/blender-session.test.mjs b/packages/blender-mcp/test/blender-session.test.mjs
index 37d58bd2f..2526e361b 100644
--- a/packages/blender-mcp/test/blender-session.test.mjs
+++ b/packages/blender-mcp/test/blender-session.test.mjs
@@ -91,6 +91,7 @@ test('the session advertises every tool with a schema', { skip: SKIP }, async ()
'blender_convert',
'blender_forge_import',
'blender_info',
+ 'blender_optimize',
'blender_render',
'blender_run_python',
'blender_scene_info',
@@ -295,3 +296,76 @@ test('an uncompressed file is passed through untouched', { skip: SKIP }, async (
const { payload } = await callTool('blender_scene_info', { input: fixture, include_objects: false });
assert.equal(payload.decoded_compression, undefined, 'nothing to decode must mean no decode step');
});
+
+test('blender_optimize hits the budget and reports an honest before/after', { skip: SKIP }, async () => {
+ // A textured fixture, so the texture half of the pass has something to do.
+ const source = path.join(workdir, 'heavy.glb');
+ await callTool('blender_run_python', {
+ output: source,
+ code: [
+ 'import bpy',
+ 'bpy.ops.mesh.primitive_monkey_add(size=2)',
+ "bpy.context.object.modifiers.new('Subd', 'SUBSURF').levels = 2",
+ "image = bpy.data.images.new('Albedo', width=1024, height=1024)",
+ "image.generated_type = 'COLOR_GRID'",
+ "material = bpy.data.materials.new('Heavy')",
+ 'material.use_nodes = True',
+ "node = material.node_tree.nodes.new('ShaderNodeTexImage')",
+ 'node.image = image',
+ "material.node_tree.links.new(node.outputs['Color'], material.node_tree.nodes['Principled BSDF'].inputs['Base Color'])",
+ 'bpy.context.object.data.materials.append(material)',
+ ].join('\n'),
+ });
+
+ const output = path.join(workdir, 'optimized.glb');
+ const { isError, payload } = await callTool('blender_optimize', {
+ input: source,
+ output,
+ max_triangles: 2000,
+ max_texture_px: 256,
+ });
+
+ assert.equal(isError, false, JSON.stringify(payload));
+ assert.ok(payload.after.triangles <= 2000, `triangle budget not met: ${payload.after.triangles}`);
+ assert.ok(payload.after.triangles > 0, 'the pass must not delete the geometry');
+ assert.ok(payload.after.texture_bytes < payload.before.texture_bytes, 'textures must shrink');
+ assert.ok(payload.output_bytes < payload.input_bytes, 'the delivered file must be smaller');
+ assert.ok(payload.saved_percent > 0);
+ assert.deepEqual(
+ payload.steps.map((step) => step.step),
+ ['decimate', 'resize_textures', 'purge', 'compress'],
+ );
+
+ // The compressed result must still be readable, which is the whole point.
+ const reread = await callTool('blender_scene_info', { input: output, include_objects: false });
+ assert.equal(reread.isError, false);
+ assert.deepEqual(reread.payload.decoded_compression, ['EXT_meshopt_compression']);
+ assert.equal(reread.payload.counts.triangles, payload.after.triangles);
+});
+
+test('blender_optimize honours compress: none', { skip: SKIP }, async () => {
+ const output = path.join(workdir, 'uncompressed.glb');
+ const { payload } = await callTool('blender_optimize', { input: fixture, output, max_triangles: 500, compress: 'none' });
+ assert.ok(!payload.steps.some((step) => step.step === 'compress'));
+ const reread = await callTool('blender_scene_info', { input: output, include_objects: false });
+ assert.equal(reread.payload.decoded_compression, undefined, 'nothing should need decoding');
+});
+
+test('blender_render returns one image per view from a single launch', { skip: SKIP }, async () => {
+ const result = await client.callTool({
+ name: 'blender_render',
+ arguments: { input: fixture, output: path.join(workdir, 'orbit.png'), samples: 4, resolution: [128, 128], views: 4 },
+ });
+ const images = result.content.filter((block) => block.type === 'image');
+ assert.equal(images.length, 4, 'every view must come back inline');
+
+ const payload = payloadOf(result);
+ assert.equal(payload.views, 4);
+ assert.equal(payload.outputs.length, 4);
+ for (const file of payload.outputs) {
+ assert.ok((await stat(file)).size > 0, `${file} must exist on disk`);
+ }
+ // The four angles must differ; identical bytes would mean the camera never moved.
+ const [first, second] = await Promise.all(payload.outputs.slice(0, 2).map((file) => readFile(file)));
+ assert.ok(!first.equals(second), 'the orbit must actually move the camera');
+});
diff --git a/packages/blender-mcp/test/registration.test.mjs b/packages/blender-mcp/test/registration.test.mjs
index 388388722..1ac3da675 100644
--- a/packages/blender-mcp/test/registration.test.mjs
+++ b/packages/blender-mcp/test/registration.test.mjs
@@ -26,6 +26,7 @@ test('exactly the expected tools are registered', () => {
'blender_info',
'blender_scene_info',
'blender_convert',
+ 'blender_optimize',
'blender_render',
'blender_forge_import',
'blender_run_python',
@@ -89,7 +90,7 @@ test('BLENDER_MCP_ALLOW_PYTHON=0 withdraws the script tool', () => {
assert.equal(child.status, 0, child.stderr);
const names = child.stdout.trim().split(',');
assert.ok(!names.includes('blender_run_python'), 'blender_run_python must not be advertised when the gate is off');
- assert.equal(names.length, 5);
+ assert.equal(names.length, 6);
});
test('blender_render is the tool that returns extra content blocks', () => {
diff --git a/prompts/store-submissions/_generated/mcp-listing-source.json b/prompts/store-submissions/_generated/mcp-listing-source.json
index 73d4f239c..6231df16d 100644
--- a/prompts/store-submissions/_generated/mcp-listing-source.json
+++ b/prompts/store-submissions/_generated/mcp-listing-source.json
@@ -421,7 +421,7 @@
"transport": "stdio",
"connect": "npx -y @three-ws/blender-mcp",
"npmPackage": "@three-ws/blender-mcp",
- "version": "0.3.0",
+ "version": "0.4.0",
"description": "Drive a local Blender headlessly: inspect, convert, render and script 3D files.",
"tagline": "Drive the Blender on your own machine: inspect, convert, render and script 3D files, headless.",
"category": "3d",
diff --git a/public/changelog.json b/public/changelog.json
index 1e78fb517..9eb250476 100644
--- a/public/changelog.json
+++ b/public/changelog.json
@@ -1,5 +1,5 @@
{
- "generated_at": "2026-09-07T06:05:18.015Z",
+ "generated_at": "2026-09-07T06:19:07.968Z",
"generated_by": "scripts/build-page-index.mjs from data/pages.json + data/changelog.json",
"site": {
"name": "three.ws",
@@ -60,6 +60,17 @@
"improvement"
]
},
+ {
+ "date": "2026-09-07",
+ "type": "update",
+ "title": "One command makes a 3D model small enough to ship, and shows you all four sides",
+ "summary": "Getting a model down to a size a web page can load used to mean writing a Blender script by hand every time: cut the polygon count, shrink the textures, throw away what nothing uses, compress the result. That is now a single request with a budget, and it answers with an honest before and after, so you can see what the size actually cost you in detail. On a test model it went from 1.3 MB to 282 KB. Previews can also orbit the model now: ask for four angles and you get four pictures from one pass, which is what tells you whether the back of a model was ever finished, or whether a texture only looks right from the front.",
+ "link": null,
+ "tags": [
+ "feature",
+ "sdk"
+ ]
+ },
{
"date": "2026-09-07",
"type": "update",
diff --git a/public/changelog.xml b/public/changelog.xml
index 832301451..32a7e58a9 100644
--- a/public/changelog.xml
+++ b/public/changelog.xml
@@ -46,6 +46,14 @@
<category>feature</category>
<description>A creator told us the making part was intuitive and the finding part was not: they built an agent, closed the tab, and had no obvious way back to it. There is now a My creations button in the header, and it opens a single page holding everything you have made, newest first: your agents, the 3D avatars saved to your account, and every model you forged, with Open, Edit and Copy link on each one. Signed out it still finds the models forged in this browser, so work made before you had an account is not lost. Filter by type, search by name or prompt, and hover any card to spin it in 3D. The create wizard and the Forge now point here too, so you are told where your work lives at the moment you make it.</description>
</item>
+ <item>
+ <title>One command makes a 3D model small enough to ship, and shows you all four sides</title>
+ <link>https://three.ws/changelog</link>
+ <guid isPermaLink="false">2026-09-07:One command makes a 3D model small enough to ship, and shows you all four sides</guid>
+ <pubDate>Mon, 07 Sep 2026 12:00:00 GMT</pubDate>
+ <category>feature</category>
+ <description>Getting a model down to a size a web page can load used to mean writing a Blender script by hand every time: cut the polygon count, shrink the textures, throw away what nothing uses, compress the result. That is now a single request with a budget, and it answers with an honest before and after, so you can see what the size actually cost you in detail. On a test model it went from 1.3 MB to 282 KB. Previews can also orbit the model now: ask for four angles and you get four pictures from one pass, which is what tells you whether the back of a model was ever finished, or whether a texture only looks right from the front.</description>
+ </item>
<item>
<title>Point an AI agent at the Blender on your own machine</title>
<link>https://three.ws/changelog</link>
diff --git a/public/features.json b/public/features.json
index 6957bdf1d..22c73271b 100644
--- a/public/features.json
+++ b/public/features.json
@@ -1,5 +1,5 @@
{
- "generated_at": "2026-09-07T06:05:18.005Z",
+ "generated_at": "2026-09-07T06:19:07.914Z",
"generated_by": "scripts/build-page-index.mjs from data/pages.json",
"site": {
"name": "three.ws",
diff --git a/public/mcp-catalog.json b/public/mcp-catalog.json
index 2444bbe8c..dd0bce380 100644
--- a/public/mcp-catalog.json
+++ b/public/mcp-catalog.json
@@ -2,15 +2,15 @@
"$comment": "Generated by scripts/build-mcp-catalog.mjs from the tool definitions and price maps in this repo. Do not edit by hand: npm run build:mcp-catalog regenerates it and npm run audit:mcp-catalog fails the build when it is stale.",
"docs": "https://three.ws/docs/mcp-safety",
"counts": {
- "tools": 316,
+ "tools": 317,
"servers": 41,
- "free": 288,
+ "free": 289,
"paid": 28,
"read": 212,
- "write": 79,
+ "write": 80,
"irreversible": 25,
- "withSchema": 316,
- "withArguments": 291
+ "withSchema": 317,
+ "withArguments": 292
},
"servers": [
{
@@ -99,7 +99,7 @@
"endpoint": "npx -y @three-ws/blender-mcp",
"transport": "stdio",
"auth": "api-key",
- "tools": 6
+ "tools": 7
},
{
"id": "brain-mcp",
@@ -4601,10 +4601,72 @@
},
"source": "packages/blender-mcp/src/tools/info.js"
},
+ {
+ "name": "blender_optimize",
+ "title": "Shrink a 3D model for delivery",
+ "description": "Make a model web-ready in one call: decimate every mesh proportionally to hit a triangle budget, scale oversized textures down, purge datablocks nothing references, and compress the mesh streams with meshopt (or Draco) on the way out. Returns before and after triangle counts, texture bytes and file size, plus what each step did, so the trade is visible rather than guessed. The input file is never modified. Decimation is collapse-based and preserves vertex groups, but a heavily decimated skinned mesh should be checked with blender_render before shipping.",
+ "server": {
+ "id": "blender-mcp",
+ "title": "@three-ws/blender-mcp",
+ "endpoint": "npx -y @three-ws/blender-mcp",
+ "transport": "stdio",
+ "auth": "api-key"
+ },
+ "safety": "write",
+ "annotations": {
+ "readOnlyHint": false,
+ "destructiveHint": false,
+ "idempotentHint": true,
+ "openWorldHint": false
+ },
+ "price": {
+ "usd": 0,
+ "free": true
+ },
+ "inputSchema": {
+ "type": "object",
+ "properties": {
+ "input": {
+ "type": "string",
+ "minLength": 1,
+ "description": "Path to the model to optimize."
+ },
+ "output": {
+ "type": "string",
+ "description": "Destination. The extension picks the format. Defaults to a .glb in the server workdir."
+ },
+ "max_triangles": {
+ "type": "integer",
+ "minimum": 4,
+ "description": "Triangle budget for the whole scene. Omit to leave geometry untouched."
+ },
+ "max_texture_px": {
+ "type": "integer",
+ "minimum": 16,
+ "maximum": 8192,
+ "description": "Longest edge any texture may keep, e.g. 1024. Omit to leave textures untouched."
+ },
+ "compress": {
+ "type": "string",
+ "enum": [
+ "meshopt",
+ "draco",
+ "none"
+ ],
+ "description": "Mesh compression for a .glb/.gltf output. \"meshopt\" (default) is what the three.ws runtime and every major web viewer decode. Ignored for other formats."
+ }
+ },
+ "required": [
+ "input"
+ ],
+ "additionalProperties": false
+ },
+ "source": "packages/blender-mcp/src/tools/optimize.js"
+ },
{
"name": "blender_render",
"title": "Render a preview image of a 3D file",
- "description": "Render a still PNG of any 3D file Blender can open (.blend, .glb, .fbx, .obj, .usd and the rest). If the scene has no camera, one is created and framed to the model; if it has no light, a key light and a lit world are added, so a bare asset file renders as a usable preview with no setup. A scene that already has its own camera and lighting is rendered as authored. The rendered image is returned INLINE alongside the JSON, so you can actually look at the model in this one call without needing filesystem access, while the full-resolution PNG is written to disk. Use it to see a model, check a conversion, or produce a thumbnail.",
+ "description": "Render a still PNG of any 3D file Blender can open (.blend, .glb, .fbx, .obj, .usd and the rest). If the scene has no camera, one is created and framed to the model; if it has no light, a key light and a lit world are added, so a bare asset file renders as a usable preview with no setup. A scene that already has its own camera and lighting is rendered as authored. The rendered image is returned INLINE alongside the JSON, so you can actually look at the model in this one call without needing filesystem access, while the full-resolution PNG is written to disk. Ask for several views and it orbits the model, rendering every angle in the same Blender launch. Use it to see a model, check a conversion, or produce a thumbnail.",
"server": {
"id": "blender-mcp",
"title": "@three-ws/blender-mcp",
@@ -4655,6 +4717,12 @@
"type": "boolean",
"description": "Render with a transparent background instead of the world. Default false."
},
+ "views": {
+ "type": "integer",
+ "minimum": 1,
+ "maximum": 6,
+ "description": "How many angles to render, orbiting the model, all in one Blender launch and all returned inline. Default 1. Use 4 to see whether the back of a model is modelled at all. A set always orbits its own camera, so an authored camera is only honoured when views is 1."
+ },
"inline_image": {
"type": "boolean",
"description": "Return the image inline so you can see it, downscaled to fit the context. Default true."
diff --git a/tests/fixtures/mcp-golden-tools.json b/tests/fixtures/mcp-golden-tools.json
index 335000418..0724629ef 100644
--- a/tests/fixtures/mcp-golden-tools.json
+++ b/tests/fixtures/mcp-golden-tools.json
@@ -2219,6 +2219,21 @@
"schemaHash": "44136fa355b3"
}
],
+ "packages/blender-mcp/src/tools/optimize.js": [
+ {
+ "name": "blender_optimize",
+ "title": "Shrink a 3D model for delivery",
+ "descHead": "dynamic",
+ "descHash": "dynamic",
+ "annotations": {
+ "readOnlyHint": false,
+ "destructiveHint": false,
+ "idempotentHint": true,
+ "openWorldHint": false
+ },
+ "schemaHash": "afe6634b5555"
+ }
+ ],
"packages/blender-mcp/src/tools/render.js": [
{
"name": "blender_render",
@@ -2231,7 +2246,7 @@
"idempotentHint": true,
"openWorldHint": false
},
- "schemaHash": "c949ad89b18d"
+ "schemaHash": "0254e6d0070d"
}
],
"packages/blender-mcp/src/tools/run-python.js": [