Deterministic Physical AI.
You can't trust an embodied system you can't reproduce. This program studies the digital twin as a verifiable, reproducible loop, fed by live IoT telemetry, rendered with WebGPU, so autonomy can be checked before and during deployment.
How the loop closes.
IoT telemetry → digital twin → a deterministic sim/AI step → WebGPU render → a divergence check against reality, and back again.
The senses
Real devices stream pose, battery, LiDAR, and sensors over the wire; the twin ingests live state.
Embedded WebGPU
Rust/WASM + WebGPU render the twin at 60 fps. No app, no cloud GPU, on the device itself.
A live replica
A synchronized virtual copy of the asset and its world. It runs forward to predict, backward to replay.
Reproducible loop
A seeded, fixed-timestep loop makes runs bit-for-bit reproducible, and flags when reality diverges.
The case you can audit.
Determinism is a set of claims, each with a method and evidence, plus an honest map of what's proven versus the open frontier. Pick a claim.
Re-running a recorded scenario reproduces the world state bit-for-bit: every contact force, every float, every step.
- Fixed timestep and a fixed solver iteration order, so no wall-clock or thread-race nondeterminism.
- Seeded PRNG; IEEE-754 round-to-nearest with fused-multiply-add disabled on the hot path.
- Each step's full state hashed (BLAKE3) into a per-run Merkle log.
- Re-running a recorded scenario reproduces the same 256-bit state hash at every step, with no divergence observed in replay testing.
- Flipping a single seed bit changes the very first step's hash, confirming the hash is load-bearing.
A fixed-point scenario yields the same 256-bit state hash across CPU architectures and WebGPU backends — auditable live on your own device, below.
- The determinism-critical path is fixed-point integer math, not floating point, so there is no vendor rounding or fast-math to diverge on.
- Compute shaders are pinned to a deterministic reduction tree rather than vendor-default parallel reductions.
- The receipt below steps a fixed-point system on your GPU (a WGSL compute shader) and on the CPU (a JS reference), then shows the SHA-256 hashes match bit-for-bit — verified live on Apple Metal, and on your device when you run it.
- On rigid-contact scenes the x86-64, ARM64, and WASM builds match bit-for-bit; float-based soft/granular paths keep their vendor-FMA audit as an open frontier.
The twin is being validated against the physical rig: predictions are held to a stated tolerance on runs the calibration never saw.
- System identification from logged telemetry; parameters calibrated once, then frozen.
- Divergence is checked on held-out runs, kept separate from the data used to calibrate.
- Acceptance bar: median trajectory error under about 2% of stroke on held-out pick-place runs, with the rig reporting the figure as validation comes online.
- Target: positional drift within a few centimeters over 30-second closed-loop rollouts.
A run becomes admissible evidence: its inputs, exact code version, and per-step hashes are signed and independently re-checkable.
- Content-addressed scenario and binary; per-step Merkle log; an Ed25519 signature over the root.
- A standalone verifier re-runs the signed scenario and re-derives the root.
- A prototype verifier re-runs a signed log and confirms the Merkle root end-to-end.
- Open frontier: a published format, third-party attestation, and certification-body acceptance.
Coverage map
Green is reproducible today; gold is in progress with known gaps; grey is the open frontier.
What we don't yet know.
The research is defined by these questions. Each one is a gap between a twin that looks right and a twin you can trust.
How faithful is faithful enough?
What is the minimal twin fidelity (physics, contact, sensor noise) that still guarantees a task-level safety property? Over-modeling wastes compute; under-modeling breaks sim-to-real transfer.
Can the web compute deterministically?
WebGPU across GPU vendors and browsers is not bit-reproducible: floating-point order, fused multiply-add, parallel reductions all differ. What primitives make a deterministic, replayable physics step possible on the edge?
When do you trust the twin over the sensor?
Real-time pairing means bounding and detecting divergence between the physical asset and its virtual replica, then deciding, under noise and dropout, which one is right.
Can a full twin run on-device?
Turnkey pairing means the twin runs inside the edge device's own browser or webview, under its memory, GPU, and thermal limits, offline. What has to be true for that to hold?
How do you sync over a lossy link?
Telemetry is intermittent, out-of-order, and lossy. How should a twin ingest it (prediction, reconciliation, backpressure) and stay synchronized without drifting away from reality?
Can the twin calibrate itself?
Differentiable physics and sensor models could let a twin tune itself to reality by gradient descent instead of hand-fitting parameters. How far does that generalize across assets?
Is a twin run admissible evidence?
If a run is deterministic, reproducible, auditable, and signed, can it serve as 'digital evidence' for certifying an autonomous system, before and during deployment?
The infrastructure the field is missing.
The questions above won't move without shared tools, benchmarks, and standards.
Reproducible web compute
Deterministic WebGPU / WASM building blocks for fixed-step, replayable simulation.
Fidelity & transfer metrics
Open benchmarks that score how well a twin predicts reality and transfers policies to it.
Telemetry & time-sync
Shared IoT schemas and clock synchronization so any device can pair with any twin.
Turnkey edge packaging
Self-contained WASM + WebGPU + OPFS bundles that deploy straight to a device's browser, offline.
A live demonstration.
A working twin: WebGPU rendering, live telemetry, and a reproducible loop.
Open the Digital Twin lab
A full-bleed instrument: the WebGPU twin, a rendering dashboard, and a live telemetry feed.
▶ Launch the live lab →Work in this area.
Open positions, including the Physical AI Investigator Program, are listed on Careers. Research here can also spin out into a company.