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 selected attempt returns with evidence, so you can decide what to keep.
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.
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.
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 ->
Point Vellum at a part, a shader, or a scene — get a verdict with the receipts.