Physa is a research project on whether idle devices can cooperate to form a shared compute field.
The idea we are studying: work travels from neighbor to neighbor like a wave, and comes back as one assembled result. A first prototype runs in controlled tests.
The model we are exploring: the requester states an intent and its constraints instead of dispatching tasks machine by machine. The field carries the work and sends back an assembled answer.
O releases a wave carrying the work, its constraints and the rules for combining results.
Each node reads the wave, keeps what it can handle, and relays the rest to its neighbors.
Fragments run locally, in parallel, inside isolated runtimes.
Partial results meet inside the field. Intermediate traffic never reaches the requester.
O receives one final result, checked against the expected answer.
The design has no central scheduler. Every node applies the same local rule. Whether reliable global behavior emerges from these local decisions is one of the things we are testing.
A graph and a compiler try to infer how a job can be split safely. Anything with an unknown structure stays whole.
A compact kernel owns the live state of each wave. Transport and storage sit behind tested boundaries.
Rust workers run ONNX models and WebAssembly modules locally, in a sandbox. Hardening that isolation is part of the security work.
Physa runs today in small, controlled tests. Each run is compared with the same computation on a single machine. These are internal experiments, not benchmarks: we do not publish performance figures at this stage.
ONNX models, a transformer encoder and a WebAssembly simulation have been split and run across small test fields, with results matching the single machine reference.
The wave logic lives in one module with a boundary enforced by tests. Transport only consumes what the kernel emits.
Overheads and gains depend heavily on the workload and the setup. Early measurements cover a few cases only and are not general results.
Tests so far are small and controlled. Behavior with many devices, varied networks and dropped connections is still to be studied.
Our working hypothesis: Physa suits divisible work where computation outweighs communication. Limits are part of the findings.
Simulation, optimization, scoring and batch AI workloads: many useful computations running side by side. This is where we expect the approach to fit best, still to be confirmed.
When a small language model was split into slices across nodes, every hop added latency and each token became much slower than on a single machine. Sequential inference looks like a poor fit.
Physa is a work in progress. A prototype engine exists; an open network is what we are working toward.
Protecting both the device that contributes and the work it receives. Encrypted transport, signed waves, real isolation, participant admission. The threat model comes first, mechanisms second.
Computers and phones can already join test fields. Staying reliable at scale through mobility, battery limits and dropped connections is an open question.
Current evidence is bounded. Thousands of nodes, varied workloads and a general economic advantage are still to be established.
Separate the specification from the implementation, so others can build compatible nodes.
Define the threats to contributors and requesters, then choose the mechanisms.
Cut fast path costs, test on separate machines, then widen devices and network conditions.
A useful computation, a reproducible reference, success criteria set before the run.