Abstract
This paper describes a dual-path implicit physics engine. The same physical scenario is evaluated through two independent channels: a text physics path where a language model renders, predicts, and reads a scene entirely in language, and a visual physics path where a diffusion model renders the scene as pixels, predicts the next physical state as frames, and a vision-language model reads the result. The delta between the two outputs is not noise. It is a measurement. Where the paths agree, the prediction is robust. Where they diverge, the system has found a scenario where language is not a sufficient proxy for physical reasoning. This delta, accumulated over time, becomes a self-generated dataset that maps the limits of language as a physics model. The architecture was discovered by accident: a misunderstood implementation suggestion produced a text-only fallback pipeline that turned out to be the baseline a physics comparison requires.
1. Introduction
A physics engine takes initial conditions and returns what happens next. That is the whole definition. Whether it uses Newton’s laws integrated forward in time, a learned neural simulation, or a statistical model over visual outcomes does not matter. The function is what matters.
This paper describes a physics engine that uses two mechanisms in parallel and treats their disagreement as data.
The text path queries what language knows about physics. Everything compressed from millions of written descriptions of physical events: causal explanations, scientific texts, narrative accounts of things falling, breaking, sliding, and colliding. The visual path queries what images know about physics. Everything compressed from photographic and video evidence of the same events, where the outcome is encoded not in words but in pixel distributions.
These are different compressions of the same underlying physical reality. They agree on the easy cases. They disagree in ways that are informative on the hard ones. The disagreement is the contribution.
2. Origin of the Architecture
This architecture was not designed. It was discovered.
During implementation of a physics reasoning component for Potato, a local AI agent, Claude Code misunderstood an instruction and proposed mirroring the GPU pipeline entirely in text: three LLM steps simulating the three GPU steps. The intent had been to ask whether real diffusion output could serve as the semantic bottleneck for dream consolidation.
The correction of that misunderstanding produced the insight. The text pipeline was not a failed fallback. It was a baseline. A control condition. You cannot measure what visual grounding contributes without a baseline that lacks it.
The dual-path architecture follows directly from that recognition.
3. Related Work
3.1 Intuitive Physics
Battaglia et al. (2013) propose that human physical reasoning operates through fast internal visual simulation rather than rule execution. Humans predict a glass will fall not by computing gravity but by imagining what it would look like if it did not fall and finding that image wrong. The reasoning is visual before it is logical.
This architecture is an empirical test of that claim. If text physics and visual physics produce systematically different predictions, that is evidence the two channels are doing different computational work. If they are nearly identical, that challenges the visual-first hypothesis.
3.2 World Models
Ha and Schmidhuber (2018) describe a world model architecture where an agent learns a compressed latent representation of its environment and uses that representation to simulate experience internally. The dual-path engine is a functional approximation: two learned world models, one in language space and one in image space, queried in parallel.
3.3 Diffusion Models as Implicit Physics
Rombach et al. (2022) describe latent diffusion models trained on photographic reality. The physics knowledge in these models is not programmed. It is emergent from training data. Every photograph of a falling object encodes that outcome. The model learned physical regularities because violating them produces images that do not look like reality.
3.4 Language Models as Implicit Physics
Wei et al. (2022) demonstrate that large language models encode substantial causal and physical knowledge accessible through chain-of-thought prompting. The text physics path treats the language model as a physics engine in the same way: not through programmed rules but through learned statistical regularities over physical descriptions.
4. The Dual-Path Architecture
4.1 Path 1: Text Physics
Three sequential LLM calls, each with a constrained role.
Step 1: Render. Given a scene description, the LLM produces a detailed visual description of the scene as if describing a photograph. It does not predict outcomes. It renders the initial state in visual language. This forces the language model to commit to a spatial, visual representation before reasoning about physics.
Step 2: Predict. Given the rendered scene description, the LLM describes what the scene looks like after the physics plays out. It is not asked to explain why. It is asked to describe the next state visually, as if describing the next frame.
Step 3: Read. Given the predicted scene description, the LLM extracts a structured prediction: what happened, to what, with what confidence.
The three-step constraint matters. A single-prompt “what happens when X?” query lets the language model shortcut directly to causal reasoning. The three-step pipeline forces it to reason through a visual representation first. That changes what knowledge it draws on.
4.2 Path 2: Visual Physics
Three components running on a local Apple Silicon machine with Metal Performance Shaders (MPS).
Step 1: Render (SD-Turbo). Text-to-image inference at 512x512 produces a scene render in approximately 5-10 seconds on the Metal GPU. SD-Turbo (~3.4 GB fp16) is the default model; SDXL-Turbo (~6.5 GB fp16) is also supported. Resolution is intentionally low. The pipeline does not need photorealism. It needs a physically plausible scene representation that encodes the spatial relationships and material properties relevant to the question.
Step 2: Predict (SD-Turbo). The same diffusion model generates a second image representing the scene after the physical interaction plays out, from a text prompt describing the predicted outcome. This is a static after-state generation, not temporal video prediction. The diffusion model’s learned priors about physical reality still constrain what the after-state looks like — objects cannot float without support, water cannot remain stacked, broken objects cannot appear whole.
Step 3: Read (Claude Haiku Vision). The before and after image pair is sent to a vision-language model (Claude Haiku in vision mode) which interprets both images and returns a structured description of the outcome in plain text. Same output format as the text path Read step, enabling direct comparison.
4.3 The Comparator
Both paths produce a structured prediction in the same format. Both are fed into the sandbox reasoning system, which runs 1-3 rounds of iterative analysis comparing the outputs.
The sandbox produces one of three classifications. Agreement: both paths predict the same outcome, confidence is high, the prediction is robust across two independent physics models trained on different substrates. Partial divergence: the paths agree on the primary outcome but disagree on details, confidence is moderate, the delta is logged. Divergence: the paths predict different outcomes, confidence is low, the system flags the scenario as at the boundary of reliable language physics.
4.4 The Delta as Measurement
The divergence cases are the primary scientific output of this architecture. Each divergence is a data point identifying a class of physical scenario where text physics and visual physics disagree. Accumulated over time, these form a self-generated dataset that maps the boundary.
Hypothesized divergence categories, to be tested empirically: fluid dynamics, where language descriptions of fluid behavior are abstract but visual models have seen water move; soft body deformation, where text physics tends toward rigid body assumptions but visual physics has seen soft materials deform; ambiguous stability, where scenes near tipping points produce different outcomes from small differences in initial conditions; and human-containing scenes, where humans are physical but intentional, and the two channels handle that differently.
5. Why Three Steps Instead of One
The single-prompt version of text physics lets the language model answer from causal knowledge directly without simulating a visual representation. This produces fluent, confident answers that may be entirely disconnected from the visual geometry of the scene.
The three-step pipeline forces a different path. By requiring the Render step first, the model must commit to a spatial description before predicting outcomes. This engages different knowledge than a direct causal query does: spatial, material, geometric.
The three-step text path is therefore not just a fallback for when the GPU is unavailable. It is a distinct query mode that accesses different knowledge in the language model. The comparison between a single-prompt query and a three-step query on the same scenario is itself informative, independent of the visual path.
5A. Calibrating the Text Baseline
The dual-path architecture described in Section 4 treats text physics as a stable baseline against which visual physics is measured. If the text path produces consistent predictions, then divergence with the visual path can be attributed to the difference in substrate: language versus pixels. If the text path is itself unstable, the measurement is confounded.
Empirical evaluation of the text path reveals that it is not stable. A companion benchmark (Riggleman, 2026b) tested the three-step pipeline against a single-prompt control on 102 physics scenarios across 11 categories, using four language models of varying size and architecture. The single-prompt condition asks the model directly what happens in the scenario. The three-step condition forces the same model through the Render-Predict-Read pipeline described in Section 4.1. Both conditions query the same model on the same scenario. The only difference is whether the model is required to commit to a spatial representation before predicting.
The results show systematic divergence between the two text conditions.
Table 5A.1. Text path internal agreement rates across four language models.
The smallest model (llama3.1:8b) diverges from itself 68.5% of the time. The largest model (DeepSeek V3) still diverges 43.2% of the time. No model tested achieves even 40% internal agreement. The three-step constraint does not produce the same prediction as the single-prompt query. It produces a systematically different one.
5A.1 Category-Level Instability
The instability is not uniform across physics categories. Some categories show high divergence across all models, while others show model-dependent patterns.
Table 5A.2. Full divergence rate by physics category. Values represent the percentage of scenarios where the single-prompt and three-step conditions predicted different physical outcomes.
Three patterns emerge from the category-level data.
Universally unstable categories. Optical_light (50-70% divergence across all models) and human_containing (44-80%) show high text-path instability regardless of model size. These categories are poor candidates for text-versus-visual comparison because the text baseline is unreliable. Any divergence between text and visual paths in these categories cannot be cleanly attributed to the visual channel.
Model-scaled stability. Fluid_dynamics shows a clean scaling pattern: 80% divergence at 8B parameters, 60% at 9B, 40% at Haiku-scale, and 10% at V3-scale. Fragile_materials shows a similar pattern (70%, 40%, 40%, 10%). In these categories, larger models produce more stable text baselines, and text-versus-visual comparison becomes meaningful above a model size threshold.
Stable categories. Fragile_materials on DeepSeek V3 shows only 10% text-path divergence and 70% agreement. Fluid_dynamics on DeepSeek V3 shows 10% divergence and 50% agreement. These are the categories where the text baseline is sufficiently stable to support the dual-path comparison described in this paper. If the visual path diverges from the text path on fragile_materials using a V3-class model, that divergence is informative.
5A.2 Implications for the Dual-Path Architecture
The text-path instability documented above does not invalidate the dual-path architecture. It calibrates it. The benchmark data provides a per-category, per-model noise floor for the text baseline. Any text-versus-visual divergence must be evaluated against this floor.
Formally: let D(text, text) represent the divergence rate between single-prompt and three-step text conditions for a given category and model. Let D(text, visual) represent the divergence rate between the three-step text path and the visual path on the same scenarios. The visual path contributes information only to the extent that D(text, visual) exceeds D(text, text). If the text path disagrees with itself 50% of the time on rigid_body, then a 55% text-versus-visual divergence on rigid_body is not evidence that visual grounding matters. A 90% divergence would be.
This reframes the hypothesized divergence categories listed in Section 4.4. Fluid dynamics was hypothesized to diverge because language descriptions of fluid behavior are abstract. The benchmark confirms this for small models (80% text instability) but shows that large models stabilize on fluids (10% text instability). The visual grounding hypothesis for fluid dynamics should therefore be tested with V3-class models or larger, where the text baseline is stable enough to measure against.
Ambiguous stability was hypothesized to diverge because scenes near tipping points are sensitive to initial conditions. The benchmark shows moderate text instability (30-40%) that does not scale cleanly with model size. This suggests the instability is inherent to the category, not to the model, and the visual path comparison on ambiguous stability scenarios should be interpreted with that baseline in mind.
5A.3 The Render Quality Signal
The benchmark scored the quality of each model’s Render step output on a 1-5 scale measuring spatial commitment: the degree to which the model specified exact positions, materials, and geometric relationships rather than hedging. DeepSeek V3 achieved an average render quality of 4.6/5. The three smaller models averaged 4.0/5.
Within DeepSeek V3, scenarios with render quality 5 showed 42.2% agreement, while scenarios with render quality 4 showed 33.3% agreement. Higher spatial commitment in the Render step correlates with higher agreement between the two text conditions. This has a direct implication for the dual-path architecture: the quality of the text path’s output depends on how fully the Render step commits to spatial detail. Vague renders produce unstable predictions.
This suggests that the Render step prompt described in Section 4.1 should be evaluated and potentially tuned per model to maximize spatial commitment before using the text path as a baseline for visual comparison.
5A.4 A Revised Interpretation of Divergence
The original formulation of Section 4.4 treated all text-versus-visual divergence as evidence that language is an insufficient proxy for physical reasoning. The benchmark data supports a more nuanced interpretation. Three classes of divergence should be distinguished:
Class 1: Text-stable, visually divergent. The text path agrees with itself (low D(text, text)) but diverges from the visual path (high D(text, visual)). This is the cleanest evidence that visual grounding captures physics that language does not. Fragile_materials and fluid_dynamics on large models are candidate categories.
Class 2: Text-unstable, visually divergent. The text path disagrees with itself (high D(text, text)) and also diverges from the visual path. This is ambiguous. The divergence may reflect visual grounding, or it may reflect text-path noise. Optical_light and human_containing fall here. These categories require additional controls or larger sample sizes to interpret.
Class 3: Text-unstable, visually convergent. The text path disagrees with itself but the visual path agrees with one of the text conditions. This would suggest the visual path is resolving an ambiguity that language cannot. This class has not yet been observed empirically and would be the strongest evidence for visual grounding as disambiguation.
The dual-path architecture as described in this paper remains valid. The benchmark data adds the calibration layer it requires: a per-category, per-model measurement of how much noise the text baseline contributes before the visual path is compared against it.
Note: This section references Riggleman (2026b), Three-Step Forced Spatial Reasoning Benchmark: Measuring What Language Models See When Forced to Look. The benchmark tested llama3.1:8b, gemma2:9b, Claude Haiku (Anthropic), and DeepSeek V3 (DeepSeek) across 102 physics scenarios using DeepSeek V3 as the evaluation judge. Additional models (DeepSeek R1:14b, Mercury diffusion LLM) are pending completion at time of writing.
6. Limitations
The visual path requires GPU hardware capable of local diffusion inference, which limits portability. The text path runs on any LLM and is available unconditionally.
The three-step constraint on the text path adds latency compared to a single-prompt query. Whether the three-step path consistently produces better-calibrated predictions than single-prompt physics queries is an empirical question not yet formally evaluated.
The divergence classification in the sandbox is currently heuristic. A formal agreement metric comparing structured prediction fields rather than full-text comparison would produce more reliable detection.
The boundary dataset this architecture generates is only as useful as the scenarios it is queried on. Systematic coverage of physics scenario types requires deliberate curation, not just accumulation from conversational use.
A further limitation: divergence between paths may reflect a failure of language description rather than a genuine physical boundary. The text path could fail on a fluid dynamics scenario not because the physics is hard but because natural language is a poor medium for encoding spatial fluid behavior. Separating these failure modes is an open problem.
7. Conclusion
A dual-path implicit physics engine using parallel text and visual pipelines produces a real-time measurement of where language alone fails as a physics proxy. The delta between outputs is not noise. It is the primary scientific contribution. Two independent physics engines trained on different substrates disagreeing is more informative than either one answering alone.
The architecture was found by accident. A misunderstood implementation suggestion produced a text-only pipeline that, rather than being discarded, was recognized as the control condition a physics comparison requires. You cannot measure what visual grounding contributes without a baseline that lacks it.
Applications of this architecture beyond physical prediction, including robotics planning, hallucination detection, and dataset generation, are described in a companion supplement (Riggleman, 2026c-S). The architecture’s relationship to deterministic simulation and its integration into a broader cognitive architecture are addressed in Riggleman (2026f).
Acknowledgments
The three-step text physics pipeline was proposed by Claude (Anthropic) during a Potato implementation session, as a misunderstanding of a different instruction. The recognition that this pipeline constituted a baseline for measuring visual physics contribution, and the dual-path architecture that followed, are original to Brian Riggleman. The diffusion-based visual physics approach using SD-Turbo/SDXL-Turbo on Apple Silicon MPS with Claude Haiku Vision as the image reader is original to this work. The theoretical framing draws from Battaglia et al. (2013).
References
Battaglia, P., Hamrick, J., & Tenenbaum, J. B. (2013). Simulation as an engine of physical scene understanding. Proceedings of the National Academy of Sciences, 110(45), 18327-18332.
Ha, D., & Schmidhuber, J. (2018). World models. arXiv preprint arXiv:1803.10122.
Rombach, R., Blattmann, A., Lorenz, D., Esser, P., & Ommer, B. (2022). High-resolution image synthesis with latent diffusion models. Proceedings of CVPR.
Wei, J., Wang, X., Schuurmans, D., Bosma, M., Ichter, B., Xia, F., Chi, E., Le, Q. V., & Zhou, D. (2022). Chain-of-thought prompting elicits reasoning in large language models. Advances in Neural Information Processing Systems, 35, 24824-24837.
Riggleman, B. (2026b). Three-step forced spatial reasoning benchmark: Measuring what language models see when forced to look. Zenodo preprint.
Update (March 20, 2026): Production validation data from 1,268 dual-path experiments and a controlled benchmark of 1,224 data points (102 scenarios × 2 diffusion models × 3 resolutions × 2 repetitions) is presented in Appendices A through E below.
Appendix A: Production Deployment Summary
The dual-path implicit physics engine ran continuously as part of the Potato agent system from March 15 through March 17, 2026, producing 1,268 physics experiments across 107 unique scenarios (mean 11.9 experiments per scenario). Experiments were triggered during the agent's nightly dream consolidation cycle, where scenarios were extracted from daily conversations and evaluated through both the text and visual pipelines.
Table A.1. Production experiment overview.
| Metric | Value |
|---|---|
| Total experiments | 1,268 |
| Unique scenarios | 107 |
| Experiments per scenario (mean) | 11.9 |
| Date range | March 15–17, 2026 |
| Dual-path method | 1,266 (99.8%) |
| Text-only fallback | 2 (0.2%) |
| Default pipeline | SD-Turbo 512×512 + Claude Haiku Vision |
| Organic dream-generated experiments | 2 (March 17) |
| Batch-run experiments | 1,266 (March 15–16) |
Each experiment produced: a text render frame (Step 1 output), a text predicted frame (Step 2 output), a structured text analysis (Step 3 output), a before image (512×512 PNG), an after image (512×512 PNG), and a metadata JSON file recording scenario, prediction, confidence, method, objects, and forces.
Table A.2. Production confidence distribution.
| Statistic | Text Path Confidence |
|---|---|
| Mean | 0.928 |
| Median | 0.950 |
| Std. Dev. | 0.043 |
| Min | 0.70 |
| Max | 0.95 |
| ≥0.90 | 1,227 (96.8%) |
When both paths were available, the sandbox comparison judged the text path as more physically accurate 91.3% of the time (1,155 of 1,265 dual-path experiments), with the GPU path judged more accurate in 7.8% (99 experiments) and unclear in 0.9% (11 experiments).
Appendix B: Controlled Benchmark Results
A controlled benchmark evaluated 102 physics scenarios across 2 diffusion models (SD-Turbo and SDXL-Turbo), 3 resolutions (256×256, 512×512, 768×768), and 2 repetitions per condition, yielding 1,224 total data points. All experiments used DeepSeek V3 as the text-path language model and Claude Haiku as the vision-path reader. Agreement scores range from 0.0 (complete divergence) to 1.0 (identical conclusions).
Table B.1. Mean agreement by model and resolution.
| Condition | N | Mean | SD | Min | Max |
|---|---|---|---|---|---|
| SD-Turbo 256×256 | 204 | 0.610 | 0.182 | 0.10 | 0.80 |
| SD-Turbo 512×512 | 204 | 0.591 | 0.198 | 0.10 | 0.80 |
| SD-Turbo 768×768 | 204 | 0.558 | 0.213 | 0.10 | 0.80 |
| SDXL-Turbo 256×256 | 204 | 0.587 | 0.189 | 0.10 | 0.80 |
| SDXL-Turbo 512×512 | 204 | 0.555 | 0.209 | 0.10 | 0.80 |
| SDXL-Turbo 768×768 | 204 | 0.521 | 0.215 | 0.10 | 0.80 |
Overall mean agreement across all 1,224 data points: 0.570. No condition achieves mean agreement above 0.62. This confirms the paper's core claim: the two paths produce systematically different predictions across a wide range of physical scenarios.
Table B.2. Mean agreement by physics category (all conditions pooled, descending).
| Category | N | Mean | SD |
|---|---|---|---|
| Granular Materials | 72 | 0.681 | 0.124 |
| Fluid Dynamics | 168 | 0.621 | 0.165 |
| Thermal | 96 | 0.608 | 0.186 |
| Ambiguous Stability | 120 | 0.601 | 0.201 |
| Human Containing | 120 | 0.563 | 0.215 |
| Rigid Body | 144 | 0.558 | 0.193 |
| Fragile Materials | 120 | 0.558 | 0.222 |
| Soft Body | 144 | 0.544 | 0.195 |
| Compound | 96 | 0.543 | 0.209 |
| Buoyancy/Density | 72 | 0.535 | 0.225 |
| Optical/Light | 72 | 0.422 | 0.215 |
The category hierarchy reveals a clear structure. Granular materials (sand, powder, soil) show the highest agreement — both text and visual models converge on predictable behavior. Optical/Light scenarios show the lowest agreement (0.422), confirming Section 5A's observation that these categories sit at the boundary where language representations of physics break down.
Table B.3. Classification distribution across all 1,224 experiments.
| Classification | Threshold | Count | Percentage |
|---|---|---|---|
| Agreement | ≥ 0.70 | 766 | 62.6% |
| Partial Divergence | 0.40–0.69 | 173 | 14.1% |
| Divergence | < 0.40 | 285 | 23.3% |
Nearly a quarter of all scenarios produce full divergence between the text and visual paths. These 285 divergence cases constitute the self-generated dataset described in Section 4.4 — each one marks a scenario where language is not a sufficient proxy for the physics the visual model infers.
Appendix C: The Resolution Paradox and Model Asymmetry
Two unexpected findings emerged from the controlled benchmark that are not predicted by the paper's original analysis.
The Resolution Paradox. Higher image resolution produces lower agreement, not higher. SD-Turbo agreement drops monotonically from 0.610 (256×256) to 0.558 (768×768). SDXL-Turbo shows the same pattern: 0.587 → 0.521. This contradicts the intuition that higher resolution provides better physical representations. One interpretation: higher resolution introduces more visual detail (textures, reflections, artifacts) that the vision-language reader incorporates into its prediction, driving it further from the text path's abstracted reasoning. The text path operates on idealized descriptions; the visual path at high resolution operates on messy, detailed images. The gap between the two widens as visual fidelity increases.
The Model Size Paradox. SD-Turbo (3.4 GB) outperforms SDXL-Turbo (6.5 GB) at every resolution, by a consistent margin of +0.023 to +0.037 in mean agreement. The larger model does not produce better-calibrated physics. Combined with the resolution paradox, this suggests the pipeline's accuracy is bounded not by image quality but by the semantic bottleneck where visual content is translated back to text by the vision model.
Confidence Asymmetry. The text path consistently reports higher confidence than the visual path across all conditions.
| Path | Mean Confidence | Median | SD |
|---|---|---|---|
| Text | 0.927 | 0.950 | 0.043 |
| Visual (GPU) | 0.730 | 0.750 | 0.126 |
| Gap | 0.198 | 0.200 | — |
The text path's near-ceiling confidence (0.927) versus the visual path's more moderate confidence (0.730) suggests the text model is overconfident — it generates fluent, certain-sounding predictions even when those predictions disagree with visual evidence. This is consistent with known calibration issues in large language models and supports the paper's argument that text physics alone is insufficient.
Appendix D: Physical Primitives
Across all 1,268 production experiments, the system detected 867 unique physical objects and 632 unique physical forces. The ten most frequently detected objects and forces provide a profile of the scenario space the engine has explored.
Table D.1. Most frequent objects across 1,268 experiments.
| Object | Count |
|---|---|
| water | 223 |
| table | 83 |
| floor | 83 |
| glass | 81 |
| person | 79 |
| hardwood floor | 59 |
| wooden table | 58 |
| air | 40 |
| glass jar | 36 |
| countertop | 30 |
Table D.2. Most frequent forces across 1,268 experiments.
| Force | Count |
|---|---|
| Gravity | 1,139 |
| Normal force | 588 |
| Friction | 499 |
| Buoyancy | 224 |
| Impact force | 185 |
| Surface tension | 173 |
| Tension | 120 |
| Air resistance | 114 |
| Drag | 109 |
| Elastic force | 48 |
Gravity was identified in 89.8% of all experiments — a sanity check confirming that the physics reasoning pipeline correctly identifies the dominant force in most terrestrial scenarios. The Token-to-Object system (Section 7.7 of the architecture, not described in this paper) additionally cached structured physical properties for 97 unique objects across all production experiments.
Appendix E: Reproducibility and Timing
The controlled benchmark ran each of the 102 scenarios twice per condition to assess reproducibility. Within-scenario variance across repetitions was computed for each condition.
Table E.1. Within-scenario reproducibility across repetitions.
| Condition | Mean Variance | Max Variance |
|---|---|---|
| SD-Turbo 256×256 | 0.024 | 0.180 |
| SD-Turbo 512×512 | 0.025 | 0.245 |
| SD-Turbo 768×768 | 0.026 | 0.245 |
| SDXL-Turbo 256×256 | 0.031 | 0.180 |
| SDXL-Turbo 512×512 | 0.032 | 0.180 |
| SDXL-Turbo 768×768 | 0.023 | 0.245 |
Mean within-scenario variance is low (0.023–0.032), indicating that the pipeline produces consistent agreement scores across runs. Maximum variance of 0.245 on some scenarios reflects genuine stochasticity in the diffusion model — the same scenario can produce different images on different runs, which the vision reader then interprets differently.
Table E.2. Timing by condition.
| Metric | Value |
|---|---|
| Mean time per scenario | 62.6 seconds |
| Median time per scenario | 60.5 seconds |
| SD-Turbo mean | 60.4 seconds |
| SDXL-Turbo mean | 64.7 seconds |
| 256×256 mean | 54.5 seconds |
| 512×512 mean | 60.3 seconds |
| 768×768 mean | 72.9 seconds |
| Total experiment time | 21.3 hours |
The full benchmark — 1,224 evaluations across 12 conditions — completed in 21.3 hours of continuous wall-clock time on an Apple Silicon machine. Timing scales linearly with resolution but not with model size: SDXL-Turbo is only 7% slower than SD-Turbo despite being nearly twice the parameter count. The bottleneck is image generation, not model loading.
Table E.3. Per-run classification distribution (A = Agreement ≥ 0.70, P = Partial 0.40–0.69, D = Divergence < 0.40).
| Run | Mean | A | P | D |
|---|---|---|---|---|
| SD-Turbo 256×256 rep1 | 0.586 | 67 | 15 | 20 |
| SD-Turbo 256×256 rep2 | 0.633 | 81 | 10 | 11 |
| SD-Turbo 512×512 rep1 | 0.596 | 68 | 17 | 17 |
| SD-Turbo 512×512 rep2 | 0.585 | 68 | 14 | 20 |
| SD-Turbo 768×768 rep1 | 0.563 | 62 | 17 | 23 |
| SD-Turbo 768×768 rep2 | 0.554 | 65 | 6 | 31 |
| SDXL-Turbo 256×256 rep1 | 0.580 | 63 | 17 | 22 |
| SDXL-Turbo 256×256 rep2 | 0.593 | 67 | 17 | 18 |
| SDXL-Turbo 512×512 rep1 | 0.541 | 57 | 14 | 31 |
| SDXL-Turbo 512×512 rep2 | 0.570 | 65 | 11 | 26 |
| SDXL-Turbo 768×768 rep1 | 0.523 | 52 | 17 | 33 |
| SDXL-Turbo 768×768 rep2 | 0.520 | 51 | 18 | 33 |
The worst-case run (SDXL-Turbo 768×768 rep2) produces 33 full divergences out of 102 scenarios (32.4%). The best-case run (SD-Turbo 256×256 rep2) produces only 11 divergences (10.8%). This three-fold difference in divergence count between the best and worst conditions demonstrates that the dual-path delta is sensitive to both model choice and resolution — a finding directly relevant to the calibration discussion in Section 5A.
Table E.4. Extreme subcategories — highest and lowest agreement.
| Subcategory | Mean Agreement |
|---|---|
| balance | 0.758 |
| ice | 0.742 |
| newtons_cradle | 0.733 |
| pressure | 0.725 |
| card_house | 0.725 |
| ... | ... |
| bicycle | 0.308 |
| refraction | 0.308 |
| mirror_redirect | 0.300 |
| orange_peel | 0.300 |
| catching | 0.258 |
The five easiest subcategories involve discrete, visually unambiguous physical events: objects balanced or stacked, collisions in simple geometries, frozen/melting transitions. The five hardest subcategories involve human motor control (catching, bicycling), optical phenomena (refraction, mirrors), and deformation of organic materials (orange peels). This hierarchy maps the boundary described in Section 4.4 with empirical specificity: where language fails as a physics proxy is not random. It is concentrated in scenarios that require either intentional agents or non-intuitive optical/deformation physics.