vork vs Blender for AI agents: speed, quality, limits and which to use

For most 3D work with an AI agent, use Blender. It has far more features, a faster path tracer in every case we have numbers for, a person-friendly interface when the agent gets stuck, and it won our one side-by-side brief. vork, which we make at Voyager, is worth choosing for a narrower job: an agent writing shots as short text files, with custom shader programs, on a supported GPU, where you want quick draft renders and the shot avoids its gaps.

The short version: choose Blender for existing scenes, fog and volumes, simulation, modelling, final path-traced frames, and anything a person will also touch. Choose vork for agent-written scenes with custom light, cameras or GPU compute, and for fast non-path-traced renders where you've checked the quality holds.

vork's numbers come from its README and benchmark results, and Blender's facts from its manual and site, all read on 6 November 2026. We also ran both on a Mac that day. We build vork and this is our comparison, so check our work: the benchmark inputs and rerun scripts are public. We will update this page as vork changes.

Key takeaways

• Blender wins most jobs: volumes, simulation, modelling, hardware support, maturity, and path tracing, where vork was 1.99 and 5.81 times slower than Cycles in the two named scenes.
• vork's default final renders beat retained EEVEE baselines by 1.14 to 2.32 times on movies in the project's measurements, with eight denoised samples against 64. They are not equal-quality comparisons, and vork can lose fine detail.
• Given the same brief, Claude Code took about seven and a half minutes on each, and Blender's picture was better. vork's scene file was a quarter of the size.

What each is

Blender is a free, complete 3D suite from the Blender Foundation, for modelling, sculpting, rigging, animation, simulation, rendering, compositing and more. Version 5.2 is the current LTS. It has two main renderers: EEVEE, a physically based real-time renderer, and Cycles, a path tracer. Agents reach it through the bpy Python API, blender -b for headless runs, or MCP, including an official server from Blender Lab. It is GPL software, with Cycles under Apache 2.0.

vork is a headless 3D and VFX engine for agents, written in Rust and Slang, rendering through Vulkan and Metal. It has no interface. A scene is JSON, written by hand or through Python and TypeScript SDKs, and rendered by one command. Scenes can include Slang programs for materials, cameras, light propagation, film response, simulation and compositing. 0.1.0 is a research preview, and it is source-available, not open source.

They aren't full substitutes. Blender replaces a whole 3D department's toolset. vork replaces only the render and scene-authoring step, for shots an agent can write.

At a glance

Sources are linked throughout; read 6 November 2026.

Authoring: what an agent actually writes

Both can be driven by text, which is the main thing. They differ in how much text.

Blender's API is huge, and it exposes years of interface decisions. Operators can depend on UI context, and because the API changes across versions, models sometimes write older calls. In return, an agent can reach almost anything, including a very wide range of formats and add-ons.

vork's surface is deliberately small. The getting-started help is about 2,500 tokens with a complete scene, and the full help about 19,400. Here is a first scene, tested on 0.1.0:

{"version":2,"nodes":[
  {"type":"mesh","geometry":{"std":"sphere","radius":1},
   "materials":[{"inputs":{"base_color":[0.12,0.35,0.65],"specular_roughness":0.3}}]},
  {"type":"mesh","translation":[0,-1,0],"geometry":{"std":"grid","size":[10,10]},
   "materials":[{"inputs":{"base_color":[0.35,0.35,0.35]}}]},
  {"type":"light","shape":"rectangle","translation":[-3,5,4],"target":[0,0,0],
   "energy":700,"size":4,"color":[1,0.92,0.8]},
  {"type":"camera","translation":[3,2,5],"target":[0,0,0]}
],"render":{"resolution":[640,480]}}

The same blocking in Blender took us about 40 lines of Python, which you can see in our headless rendering guide. Materials use OpenPBR inputs, and cameras and lights follow Blender's physical conventions. Unknown fields are errors that suggest the nearest valid name, and in our run the agent corrected one on the next try.

Choose Blender if you need the reach. Choose vork if a small, strict surface matters more, and your scene can live inside what it offers.

The agent test: one brief, one run each

We gave Claude Code the same brief for each: a red toy rocket on a wooden table at dusk, preview, refine, final still and three-second video, 960x540 at most. The full walkthrough has the prompts and details.

Blender's picture was better, and it hit no errors. vork's file was a quarter of the size and its video rendered in 50 seconds against about two minutes at a higher sample count, but that isn't what you would look at. It's one run of one brief. Our permissions also kept the vork agent off the Python SDK, though both runs were limited in the same way on ffmpeg. Take it as a signal, not a score.

Choose Blender if you are starting from a loose brief and care how the first result looks.

Speed

This is where it gets easy to mislead, so here are the numbers with their conditions. Draft and final figures are complete command times on one frozen build on an NVIDIA L4, from the project's results; the path figures are carried forward from an earlier build. Blender times are retained from earlier runs with different settings: EEVEE uses 64 samples with no denoiser, and vork std/final uses eight with a denoiser. The project says these are not equal-quality speedups, and visual review found softer edges, grainier defocus and changed highlights.

Preview renders are vork's largest speed difference. On the prior build, std/previs ran 14.63 to 36.40 times faster than EEVEE over seven simple clips, which helps an agent's iteration loop, but previews have different lighting and shadows and aren't final quality.

On a tiny scene on our Mac, the gap was under half a second: warm std/final took about 0.43 seconds at 640x480, EEVEE about 0.83 seconds, and Cycles 2.2 to 4 seconds. The Cycles image was the cleanest.

Then there's the bird shot. vork rendered eight seconds of a million simulated birds at 1080p24 and four samples in 97 seconds, using Slang compute. EEVEE at the same four samples is projected, not measured, at 13 to 18 minutes, or 8 to 11 times longer. That projection extrapolates eight warm frames across two retained runs and hands Blender the finished flock as geometry. It leaves out simulation, startup and encoding. vork's 97 seconds leaves out setup and a one-time warmup. The camera and nine foreground birds are authored, and the simulated million do not flap.

Choose Blender for path-traced finals and when you can't verify lower-sample quality. Choose vork for fast drafts and for scenes like the flock where GPU compute is the shot.

Quality and looks

At its default sample counts, vork gives up detail for speed. The README lists softer edges, fine facades and hair losing detail, stepped or grainy defocus, wall mottling, and sparse sparks or spectral highlights changing brightness and colour. --set samples=32 helps, at more cost. Its default std/final also approximates indirect lighting and can darken interiors, and more samples don't restore what it omits. std/path addresses that but is slower.

Blender's Cycles is a well-proven reference, and EEVEE is a mature real-time option with its own well-understood approximations. We would not claim vork's looks match either in general.

Choose Blender when the frame has to hold up to scrutiny without manual checking.

Credit: Cozy Kitchen (Blender 3.5 splash scene) by Nicole Morena, source .blend, CC BY-SA (version unspecified by source). Adapted and rendered in vork: camera orbit, animated lighting, widescreen framing, material translation and staging changes. This adapted animation is shared under CC BY-SA. No artist endorsement implied.

Custom programs: where vork is different

Blender lets you script nearly everything and offers shader nodes, plus OSL shaders and custom cameras in Cycles. We found no documented public hook for curved light propagation. vork exposes one. A scene can supply a program that changes how camera rays, material response, light propagation and film response behave, with no renderer edits. The black hole example supplies Schwarzschild light propagation this way, and the million birds are steered by compute programs in the scene. Both are shots an agent can write as text, though these programs still take skill and a lot of checking. The black hole is a numerical approximation, not an exact solver.

The cost is that new programs compile on first use, and that can take minutes on NVIDIA. Choose vork if your shot needs that kind of control.

Reliability

Blender has decades of production use. vork is new. Large scenes and dense transparency can fail, including on Mac, and reducing resolution doesn't necessarily fix it. Solid glass and heavy interiors can abort on Apple Silicon, where a retry sometimes succeeds. Its frozen benchmark sweep on Linux and NVIDIA delivered 583 of 585 images, with one stress scene running out of GPU memory in both profiles; Mac reliability was not revalidated in that run.

Choose Blender for anything you can't afford to redo.

Hardware, licence and cost

Both are free to use today. Blender's GPL grants it to you for any purpose, permanently, and your output is your own. vork is free during the preview for any use, including commercial work, and what you make is yours. But later versions may have different terms, you can't redistribute modified versions or offer vork as a hosted rendering service without permission, and it isn't open source.

On hardware, Blender runs far more widely, including on CPU with Cycles. vork needs a recent NVIDIA GPU with a ray tracing driver, or Apple Silicon. AMD, Intel and software rendering aren't supported, which rules out most cheap cloud instances and CI runners.

Using them together

You don't have to choose once. The vork repository includes an optional Blender bridge, a separate GPL component that is not part of the renderer or SDK packages, and it exports a .blend to files vork can render:

blender -b --disable-autoexec source.blend --python integrations/blender/export.py -- --out /tmp/vork-scene

It lives in the vork repository, and it writes a report of each material variant, substitution and missing feature. Expect differences from the original look, as with the kitchen above. We did not run the bridge for this post.

Verdict by job

Frequently asked questions

Is vork better than Blender?

Not overall. Blender has more features, a faster path tracer in the measured cases and far wider hardware support, and did better in our single agent test. vork is better for a narrower job: agents writing scenes as short text, custom programs in the scene, and quick drafts.

Is vork faster than Blender?

Sometimes. On the README's measured scenes, default final renders ran 1.14 to 2.32 times faster than retained EEVEE baselines, at fewer samples with denoising and not at equal quality. vork's path tracer was 1.99 to 5.81 times slower than Cycles. First renders of new programs can take minutes.

Can vork import Blender files?

Through an optional bridge that exports a .blend to scene files, not directly. It also imports glTF. Materials are translated and reported, not guaranteed to match.

Does vork have a GUI?

No. It's a command-line engine for agents, and you review its output as images and video.

Can Claude use Blender without MCP?

Yes. blender -b -P script.py is enough. We used that route in our test. Our MCP guide covers when live control is worth it.

Is vork open source like Blender?

No. Blender is GPL. vork is source-available under the vork Preview License: free during the preview and modifiable for your own use, but you can't redistribute modified versions or host it as a service without permission.

Will vork get fog and volumes?

The README names fog and volumes, broader simulation, and better reliability on demanding scenes as the next direction, with no release date promised. Check vork help limits for your version.