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.
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.
When the work is a shader or a look, Vellum writes several candidates, compiles each one, and scores them on what they actually output — not a vibe. The winner is the one that passed every assertion. Drag the slider to compare the rejected candidate with the selected one; the panel shows exactly why one won. No graphics card touched this.
Vellum is a complete editor: a scene graph, physics, lighting and a play mode, with the agent and the proof built in. Lay out a level, press play, and it runs an automated playtest on the CPU — pathing the navmesh, checking collision, reaching the goal — and reports the same renderer-neutral verdict you get everywhere else. Hit play.
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.
“A printable bracket that holds 2 kg, under 60 g.” Plain language in, a spatial task out.
The agent writes the part, the shader or the scene — often several candidates at once.
Each candidate is loaded, asserted, rendered headless and measured against the target.
The winner is the one that passed — returned with its proof, not a promise.
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.
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.
Every result clears geometry, tolerance, collision and a headless render before it counts.
Points it at your scene or part and it understands the geometry — meshes, BREP, point clouds.
Give it a number — mass, clearance, frame budget — and it proves the work hits it.
The whole verifier runs on CPU, so it works the same on a laptop or a headless CI box.
Reads and writes glTF, USD, STEP and URDF — drop it between the tools you already use.
The same input gives the same verdict — every run, every machine, every time.
Attempts a task several ways in isolation and keeps the one that actually passes.
CPU proof runs the same on a laptop, a CI runner, or a render farm.
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.
Vellum's editor, engine and proof kernel are free to run locally — no account needed. A single Ephemerent subscription unlocks cloud agents in Vellum and the Orrery IDE together: same sign-in, same bundled DeepSeek models, one shared monthly token quota metered server-side.
Quotas are shared across Orrery and Vellum and auto-renew monthly via Stripe; cancel anytime. Bundled-model prompts are proxied to DeepSeek. Terms · Privacy. Already subscribed? Connect Vellum to your account →
Point Vellum at a part, a shader, or a scene — get a verdict with the receipts.