3D work that
proves itself.
Vellum is a full game engine — and a spatial agent layer for robotics, engineering and modeling. It builds the 3D work — scenes, shaders, CAD parts, kinematic rigs — then proves each result against real constraints: compiles, watertight, in tolerance, collision-free. The proof is renderer-neutral and runs headless on the CPU. No GPU in the loop.
The proof runs on the CPU — the same verdict on a laptop, a CI runner, or a render farm.
Topology pending
Raster pending
It doesn't just make 3D. It proves it.
Most tools generate geometry and hand you a pretty render to eyeball. Vellum generates the work and then runs it through a verifier — a chain of spatial assertions that either pass or fail. Pick an artifact and watch the proof run: it loads, checks the geometry, measures against a target, and returns a verdict. Every check runs on the CPU, so there's nothing to eyeball and nothing to trust on faith.
A frame shows appearance. Evidence answers constraints.
The live bench above separates what was rendered from what was measured. A CPU frame confirms that the raster worker produced pixels; topology and boundary checks answer different questions. Vellum keeps those claims distinct so a polished image cannot stand in for proof.
Measurements on this page come from the in-browser CPU worker. If that worker is unavailable, the proof reports “Not run” instead of substituting sample results.
One spatial stack, with explicit boundaries.
Vellum brings authoring, runtime checks, and proof into one spatial system. The diagram below describes that contract; it is deliberately not a fabricated editor screenshot. The live scene and worker output above are the page's visual and measured artifacts.
Build the spatial artifact
Scene graph, entities, geometry, materials, and the task target share one project boundary.
- Scene and asset structure
- Format-aware editing
- Explicit target constraints
Exercise the runtime
Configured physics, collision, path, and scene checks run against the artifact rather than a marketing render.
- CPU spatial kernel
- Headless execution
- Interruptible checks
Return a receipt
Measured outputs stay attached to their method and input, leaving the acceptance decision with you.
- Assertions and measurements
- Worker-produced frame
- Pass, fail, or not run
From a prompt to a provable result.
Every job follows the same path. Vellum can attempt a task several ways in isolation, prove each attempt the same way, and keep only the candidate that clears the bar — then hand you the verdict and the numbers behind it.
Describe
“A printable bracket that holds 2 kg, under 60 g.” Plain language in, a spatial task out.
Generate
The agent writes the part, the shader or the scene — often several candidates at once.
Prove
Each candidate is loaded, asserted, rendered headless and measured against the target.
Review
The selected attempt returns with evidence, so you can decide what to keep.
One proof.
Every renderer.
Vellum's verdict doesn't depend on a renderer, a driver, or a graphics card. It reads and writes the formats you already use, and proves the work against a neutral spec — so a part that's watertight in Vellum is watertight in Blender, and a scene that passes here passes in Unreal. Bring the engine; keep the proof.
The live proof bench supplies the values. This schema intentionally contains no sample success metrics.
Every result has a receipt.
Vellum keeps a running record of every assertion, measurement and render as it works — so you can see why a result was kept, what each candidate scored, and what it would do in your engine, without rerunning anything on a GPU.
Proven before it's kept
Every result clears geometry, tolerance, collision and a headless render before it counts.
Reads your assets
Points it at your scene or part and it understands the geometry — meshes, BREP, point clouds.
Explicit targets
Give it a number — mass, clearance, frame budget — and it proves the work hits it.
No GPU required
The whole verifier runs on CPU, so it works the same on a laptop or a headless CI box.
Fits your pipeline
Reads and writes glTF, USD, STEP and URDF — drop it between the tools you already use.
Deterministic proof
The same input gives the same verdict — every run, every machine, every time.
Best-of-N, judged
Attempts a task several ways in isolation and keeps the one that actually passes.
Headless by default
CPU proof runs the same on a laptop, a CI runner, or a render farm.
A spatial kernel and an agent core.
A CPU spatial kernel does the geometry and the headless rendering; a separate agent core decides what to build and how to prove it. One stable contract joins them — each part runs offline, predictable and testable.
The spatial kernel · CPU
The agent core
Ways to run it
One subscription. Both apps.
A single Ephemerent subscription unlocks cloud agents in Vellum and the Orrery IDE together: same sign-in, hosted DeepSeek API, Doubleword, and Arbiter credits, proof receipts, and one shared account.
Pro
- Cloud agents in Vellum + Orrery
- DeepSeek API - 200M credits/mo
- Doubleword - 200M credits/mo
- Arbiter - 100M credits/mo
- Est. ~$2,400 API usage value/mo
- Nexus operations
Max
- Everything in Pro
- DeepSeek API - 600M credits/mo
- Doubleword - 650M credits/mo
- Arbiter - 400M credits/mo
- Est. ~$7,500 API usage value/mo
Ultra
- Everything in Max
- DeepSeek API - 1.5B credits/mo
- Doubleword - 1.5B credits/mo
- Arbiter - 1.2B credits/mo
- Est. ~$18,000 API usage value/mo
Credits are shared across Orrery and Vellum and auto-renew monthly via Stripe; cancel anytime. Hosted-model prompts are proxied through Orrery Cloud. Terms | Privacy. Already subscribed? Connect Vellum to your account ->
Stop eyeballing 3D.
Start proving it.
Point Vellum at a part, a shader, or a scene — get a verdict with the receipts.