Move the compute, not the data.

Publish once

Data is identified by its BLAKE3 hash. A dataset read by a hundred tasks crosses the wire once, and repeated chunks never cross it at all.

Score, don't rotate

compute + transfer + latency − locality. Every weight is configurable, and the score comes back term by term, so you can see why a node was chosen.

Run other people's code safely

Tasks are WebAssembly with a fuel budget and no host access. An endless loop costs one task, not the node.

Some machines are not interchangeable

Nodes declare what they are — gpu=true, region=eu-west — and a task says what it needs. If nothing qualifies, the task is refused rather than placed somewhere it was not allowed.

Idle costs almost nothing

A node with nothing to do doubles the gap between heartbeats, up to half the controller's eviction window. Work, or a real change in load, snaps it straight back.

Small enough for a Pi

A 1.3 MB controller and a 2.7 MB agent, pure Rust, no C toolchain to cross-compile for aarch64 or armv7.

1 · Publish

The client hands the controller bytes. They are hashed, and that hash is the name they are known by from then on.

2 · Score

Every live node is scored on load, measured latency, measured bandwidth, and how much of the task's data it already holds.

3 · Move only what is missing

The winner receives the chunks it does not have — compressed if the link is slow enough to be worth it, split across several connections if it offered them.

4 · Run and answer

A built-in task or a sandboxed module runs, and the result comes back on the same connection. A node that dies mid-flight gets the task retried elsewhere.

TypeScript

const mesh = await AetherMesh.connect({ port: 7100 });
const mod  = await mesh.publishFile("task.wasm");
await mesh.runWasm(mod.dataId, input);

Python

with AetherMesh.connect(port=7100) as mesh:
    data = mesh.publish(payload)
    mesh.run("hash", b"", inputs=[data.data_id])

Go

mesh, _ := aethermesh.Connect(aethermesh.Options{Port: 7100})
data, _ := mesh.Publish(payload)
mesh.Run("hash", nil, []string{data.DataID})

Java

try (var mesh = AetherMesh.connect(opts)) {
    var data = mesh.publish(payload);
    mesh.run("hash", seed, List.of(data.dataId()), List.of());
}

C#

await using var mesh = await MeshClient.ConnectAsync(opts);
var data = await mesh.PublishAsync(payload);
await mesh.RunAsync("hash", seed, inputs: [data.DataId]);

Already using a thread pool?

The Python SDK ships a real concurrent.futures.Executor, so submit, map, and as_completed keep working — only the constructor changes.

with MeshExecutor.connect(port=7100) as pool:
    pool.map(pool.builtin("hash"), payloads)