Where to start

Check our work

If you're investing

← PRODUCT

HOW IT WORKS

One goal, five steps, no coordinator.

Every robot periodically broadcasts a small authenticated frame that carries what it knows: its neighbors, which jobs are done, and who claims which job. The merge rule is commutative, associative and idempotent, so the swarm converges to one view no matter how frames are delayed, repeated or reordered.

Split. Agree. Do once. Prove. Learn.

NO COORDINATOR

Every robot broadcasts what it knows to its neighbors. The swarm converges to one view with no server and no reliable link.

ONE START PER JOB

A claim with a bid, a settle time of two periods, then a START that dominates every claim. Exactly one robot starts each job.

NOTHING TO TRUST

Finished work is signed, bundled and anchored on SUM Chain. Anyone can check it without trusting the operator.

THE LOOP

Split, agree, do once, prove, learn.

A signed goal becomes a tree of jobs. A robot claims a leaf with a bid, waits a fixed settle time, then announces it has started. Finished work is signed and bundled. The bundle hash goes on chain and the raw data goes to storage. Idle robots train on that data, and the better models flow back.

SwUM: one goal, five steps A signed goal is split into jobs, the fleet agrees who takes each job over one-hop radio, exactly one machine starts each job, finished work is signed and its hash anchored on SUM Chain, and idle machines train on the outcomes through OmniNode. 01 Split A SIGNED GOAL BECOMES JOBS 02 Agree BID OVER ONE-HOP RADIO 03 Do once ONE ROBOT STARTS EACH JOB 04 Prove SIGNED, HASH ON SUM CHAIN 05 Learn TRAIN ON OUTCOMES WHEN IDLE ONE RADIO FRAME PER BEACON · RUNS ON A MICROCONTROLLER

ALLOCATION

Exactly one robot starts each job.

A claim carries a bid. The claimant waits two dissemination periods, long enough for a better bid to arrive, then sends a START marker that dominates every claim. The first draft waited one period. The numerical checks showed double starts, so the rule became two. That is Theorem 4, and two periods is the minimum.

Claim, settle, START: exactly one robot starts each job Robot A sends a CLAIM carrying its bid, waits a settle time of two dissemination periods, then sends START. Robot B's lower bid arrives inside the settle window and loses, and once START is heard no other robot starts the job. Robot A Robot B TIME SETTLE · 2D CLAIM CLAIM START SETTLE 2D, THEN START · ONE ROBOT PER JOB

ARCHITECTURE

Five planes, one invariant.

Link, coordination, autonomy, settlement and learning. Each plane has one job and a narrow interface to its neighbors. Safety lives in the coordination plane and holds whatever the models, the chain or the backhaul are doing. No model can break it, because the rules are enforced outside the models.

SwUM: five planes, one invariant SwUM runs as five planes stacked inside each robot: link, coordination, autonomy, settlement and learning. Safety lives in the coordination plane, which holds shared state, claims, START and leases. SUM Chain, SNIP and OmniNode sit outside the robot: settlement sends a bundle hash to SUM Chain and episode packs to SNIP, SNIP sends training data to learning, learning sends weight deltas to OmniNode, and OmniNode sends new model versions to autonomy. Link RADIO · ONE-HOP FRAMES Coordination STATE · CLAIM · START · LEASE Autonomy BIDS · MODELS Settlement RECORDS · BUNDLES Learning IDLE-TIME TRAINING OmniNode SUM Chain SNIP SAFETY LIVES IN THE COORDINATION PLANE

ON THE ROBOT

Two tiers in every robot.

Tier 0 is a microcontroller running no_std Rust: the radio, the link protocol, the shared state, the allocation rules and integer inference. It keeps working when the robot is isolated. Tier 1 is a companion computer that holds the small models, builds the records and bundles, and talks to SUM Chain, SNIP and OmniNode when a backhaul is available.

SwUM: two tiers in every robot Each SwUM robot holds two tiers inside one boundary. Tier 0 is the link controller on a microcontroller, no_std Rust, running the radio, the link protocol, the replicated state, the allocation rules and integer inference; it is everything that keeps working when the robot is isolated, and it reaches other robots over one-hop radio. Tier 1 is the Linux companion computer that holds the skill stack of small models, builds records and bundles, runs the trainer, sends setpoints to the vehicle controller and talks to the backhaul (SUM Chain, SNIP, OmniNode) only when one is available. The two tiers are joined over UART or SPI. UART / SPI RADIO Tier 0 LINK CONTROLLER Tier 1 COMPANION COMPUTER Vehicle controller Other robots Backhaul TIER 0 KEEPS WORKING WHEN THE ROBOT IS ISOLATED

JOB DONE

Prove it on chain. Learn from it later.

A finished job becomes a signed 196-byte attempt record. Records are bundled, and the bundle hash is anchored on SUM Chain. The success and failure data goes to SNIP as an episode pack. A robot with no job fetches packs, trains through OmniNode and publishes a weight delta. The hash of the new model lands in the next bundle.

Learning loop: prove it on chain, learn from it later When a job is done the robot signs an attempt record; the bundle hash goes to SUM Chain, the raw episode pack goes to SNIP, an idle robot trains on that data through OmniNode, and the new model flows back to the swarm. BUNDLE HASH EPISODE PACK TRAINING DATA NEW MODEL Robot SUM Chain SNIP OmniNode PROOF ON CHAIN · DATA ON SNIP · MODELS BACK

THE MODELS

Scenario writer A small language model writes the scenario and the choices.
Selector A Laya-based fine-tune gives each choice a probability.
Specialists One small model per job kind does the work.
JobNet-bid Produces the bid for each job from local observations.
CommNet A permutation-equivariant graph network decides when and what to send, which lowers radio cost.