Test plan · Generators
How to Measure Run-to-Run Variance in AI 3D: Seeds, Reruns and What Vendors Document
Why one good AI 3D output proves little: how to rerun a prompt five times, measure run-to-run variance, and what vendors document about seeds and variations.
On default settings, generative tools generally return a different model each run, so a single output is a sample, not a score. If you judge a tool on the one result you liked, you are buying the good draw, not the average. This page explains how to measure run-to-run variance, what vendors document about seeds and retries, and when to repeat a prompt before deciding.
What is documented, and what is not
The sources we read say little. Meshy’s comparison post (updated 27 October 2026; it discloses that Meshy is one of the tools compared) lists output consistency across repeated runs as not measured. This page is one of the protocols in the tests hub. We looked for a published run-to-run variance test and found none among the pages we read, which is a limit of our reading, not proof that none exists.
Seeds are the usual way to make a generative model repeatable, and whether you get one depends on the tool and the surface. This is what the reference pages showed in November 2026:
| Tool and surface | Seed control in what we read | Scope note |
|---|---|---|
| Tripo API, H and P series | model_seed for geometry and texture_seed for texture; text-to-3D adds image_seed for its internal text-to-image stage. Unset means random each run |
Tripo says the same seed and input “will produce an identical 3D mesh”. API only: its FAQ asks whether API and Studio results match, but the answer was not in the page text we could read |
| Meshy API | No seed parameter on the Image to 3D, Text to 3D or Multi-Image to 3D references | Web app not covered by those pages |
| Rodin / Hyper3D API | Optional seed integer on the Gen-2.5 page (0 to 65535) and on the Gen-2 page |
Described only as “A seed value for randomization in the mesh and texture generation”. Neither page promises identical output from a repeated seed, so this is one to verify in Arm B |
| Hunyuan3D-2.1, local | The demo has a Seed slider and a Randomize seed checkbox, and passes the value to generator.manual_seed |
Read from gradio_app.py |
| TRELLIS v1, local | The README example passes seed=1 to the pipeline |
Example code |
| TRELLIS.2, local | run() takes seed: int = 42 and calls torch.manual_seed; the demo app starts with Randomize Seed on |
Read from the pipeline and app source |
Where a row says none, check the current reference and UI yourself, and record “not exposed” only if it is absent there.
Retries are a separate feature that is easy to confuse with repeatability: Meshy’s pricing page lists free retries per task in the web app on paid plans (4 on Pro, 12 on Premium, 40 on Ultra), and does not explain what a retry does. If it is a reroll inside the same task, it is a way to take more samples, and a reason to log how many you used.
What a seed does not promise
A documented seed is a claim to verify, and it only covers one exact configuration. Four things sit outside it.
- The model version. Runware, an inference vendor documenting its own platform, says two different models given the same seed produce completely different output. Meshy’s
ai_modeldefaults tolatest, which currently resolves to Meshy 7.1, so an unpinned call can change under you. Tripo publishes dated snapshots such asv3.1-20260211; send one explicitly. - Every random stage. Tripo’s text route has three seeds. Our reading of its parameter notes is that a text-route run needs all three fixed, because
model_seedpromises a repeat only for “the same input” andimage_seedcontrols the image that becomes that input. - The sampler. Runware says stochastic schedulers add randomness at each step, so even a fixed seed can differ slightly between runs. That page is about its model catalog in general. Whether a given 3D pipeline uses such a step is something to read in its code or measure.
- Hardware and libraries. PyTorch’s documentation says “Completely reproducible results are not guaranteed across PyTorch releases, individual commits, or different platforms”, and that results may differ between CPU and GPU “even when using identical seeds”. TRELLIS.2 seeds through PyTorch, and Hunyuan3D-2.1’s demo seeds a PyTorch generator. That is a statement about the framework, not a measurement of either model, but it means a local seed is safest treated as valid for one machine and one environment. Log GPU, driver and PyTorch version.
Repeatability is also not archiving. Meshy’s Terms say API output for non-Enterprise customers is deleted three days after generation (its pricing table agrees for Pro, Premium and Ultra but lists 14 days for Studio), and that it may remove web-app output over a storage limit or tied to an inactive account. Keep the raw file of anything you approve, whatever the seed says.
Decide what “the same” means first
Reproduced is a claim with three possible strengths, and each needs a different check.
| Level | Check | When you need it |
|---|---|---|
| File-identical | Compare a SHA-256 hash of each download | Build systems and audit trails. A mismatch can come from embedded metadata or a re-encoded texture, so on its own it proves little |
| Geometry-identical | Equal triangle and vertex counts, equal bounding box, and closest-point distance between runs within a tolerance you declare | Regenerating an approved asset after losing the file |
| Design-stable | layout_diff of none or minor, scored blind |
A set of props that must look related |
GeometryOS, in a March 2026 article written from a pipeline vendor’s position, argues a production gate should use a “byte-level or geometry-structure diff tolerance”. That suits automated pipelines. Most solo developers buying credits care about the third row, and should not pay for a seeded workflow to get the first.
What you are measuring
The protocol has two arms, because they answer different questions.
Arm A, unseeded variance. One prompt, five runs, default settings, same tool and pinned model version, same day if possible. Leave seeds unset. Compare the runs to each other. This is what a normal user gets, and it feeds cost planning.
Arm B, seeded reproduction. Only where a seed is exposed. Pick one value, run the same input three times with every seed field, setting and model string fixed, and grade the results against the levels above. On Tripo, run a further pair that keeps model_seed and changes only texture_seed, since its docs describe that as the way to get new textures on the same geometry. If the geometry moves, the documented separation did not hold on your input.
| Field | Definition |
|---|---|
| run_index | 1 to 5 for a given prompt and tool |
| seed_control | exposed and fixed / exposed and random / not exposed |
| seed_values | Every seed field sent or returned, or blank |
| model_snapshot | The exact model string, never latest alone |
| file_hash | SHA-256 of the raw download (Arm B) |
| geometry_distance | Closest-point distance between run pairs after alignment, as a share of the bounding-box diagonal (Arm B) |
| triangles | Triangle count of the raw download, from the script on the prompt set page or any one mesh tool used for every run |
| loose_pieces, open_edges | Disconnected islands and edges with one adjacent face, measured the same way |
| gate_pass | pass or fail against the class gate |
| score_prompt, score_silhouette | 0 to 2, scored blind with run IDs only |
| layout_diff | Do the five runs differ in pose, proportions or major features? (none/minor/major) |
| credits | Credits per run |
Derived values to compute after the runs: the spread of triangle count (maximum minus minimum, and as a share of the median), the number of runs out of five that pass the gate, and the gap between the best run and the median run.
The decisions it informs
- Pass rate across five. If
pof five runs pass the gate, you paid for 5 ÷pruns per usable asset on that prompt, plus your selection time. That arithmetic belongs in cost per usable asset; this protocol gives you the rate to feed it. - Best versus median. A big gap means marketing pages and reviews that show the best run overstate typical output. Compare the median run across tools, not the best.
- Style stability. For a set of assets that must look related, layout_diff and score variance tell you whether the tool can hold a look; see keeping a consistent style.
- Whether a seed is worth building around. If Arm B reproduces at the level you need, you can store a seed and model string instead of relying on luck during iteration. If it does not, treat every approved output as unrepeatable and archive it.
Pass or fail
Set the threshold before running: a tool passes a prompt if at least four of five runs pass the class gate and the triangle-count spread stays within a range you declare for your engine budget. Report prompts where it fails rather than averaging them away. Run ten prompts across classes (the standard set has five classes) so a tool that is steady on props but erratic on creatures shows up.
When the runs will not line up
Most surprises trace to something that changed besides the seed.
| What you see | Check first |
|---|---|
| Same seed, different mesh | Is the model string a dated snapshot? Is the input file byte-identical? Were all seed fields and settings identical? |
| Same geometry, different texture | Whether texture has its own seed. Tripo documents one; a geometry seed alone does not cover it |
| Reproduced last month, not today | An alias moved, or the vendor changed the system without a version bump. Tripo’s retarget docs say its algorithm “has been replaced in place” with “no new version number”, which shows this can happen. That page covers animation, not generation |
| Local runs differ between machines | PyTorch release, GPU and driver, per the PyTorch note above |
| Similar look, very different triangle counts | Polycount settings. Tripo’s face_limit, when omitted, leaves the model on adaptive topology, so count varies by design |
| One run of five is far off the others | Keep it in the table. Dropping outliers is how a tool’s variance disappears from a comparison |
Limits
Five runs is a small sample. It can reveal a tool that is wildly inconsistent but cannot give a reliable rate. The binomial distribution shows how little it pins down: five passes out of five is compatible with a true pass rate as low as about 55% at 95% one-sided confidence (0.05 raised to the power 1/5), and twenty straight passes only lifts that floor to about 86%. That is arithmetic about sample size, not a result for any tool. Use more runs for a decision that costs real money. Variance can also change after a model release, so retesting is covered in model version changes. Failure and queue behavior is logged separately in the failed runs and queue logging.
Sources
- Meshy blog: Hi3D vs Meshy vs Tripo
- Meshy pricing
- Hunyuan3D-2.1 repository
- Tripo API: Image to 3D Model, H Series
- Tripo API: Text to 3D Model, H Series
- Tripo API: Animation Retarget
- Tripo developer site
- Meshy API: Image to 3D
- Meshy API: Text to 3D
- Meshy API: Multi-Image to 3D
- Meshy Terms of Use
- Rodin Gen-2.5 API specification
- Rodin Gen-2 API specification
- Hunyuan3D-2.1 gradio_app.py
- TRELLIS README
- TRELLIS.2 image-to-3D pipeline source
- TRELLIS.2 demo app source
- PyTorch: Reproducibility
- Runware: Seed
- GeometryOS: AI Can Generate Meshes, But Pipelines Still Break