Spatial Robotics

    Small-world coordination, first-class

    Coordinate thousands of robots like a small world.

    Spatial Robotics builds small-world networks for multi-robot coordination — balancing local efficiency against global awareness so a swarm reaches agreement in a few hops, not a full mesh. Design topologies, inject failures, and benchmark consensus entirely in your browser.

    Open the StudioView Benchmarks
    • Watts–Strogatz topologies
    • Python · C++ · ROS2
    • No GPU required

    live · watts_strogatz · n=28

    Avg path
    2.53
    hops between robots
    Clustering
    0.27
    local cohesion
    Propagation
    11.1×
    reach / tick

    A handful of long-range shortcuts (in blue) collapse the network diameter — the small-world effect, live.

    The platform

    From graph theory to robots in the field

    One core powers the design studio, the benchmark suite, and the on-robot SDK — so the network you prototype is the network you deploy.

    • Small-world graph construction

      Watts–Strogatz, Barabási–Albert, k-regular, and our proprietary Spatial Small-World — tuned to balance local clustering against global reach.

      • β rewiring control
      • 4 topology families
      • Spatial constraints
    • Message-passing & consensus

      Average, max, and weighted consensus plus Hungarian and auction allocation. Watch agreement propagate hop-by-hop across the swarm.

      • 7 coordination policies
      • Bandwidth-aware
      • Per-tick message ledger
    • Discrete-time simulator

      Deterministic, seeded, tick-by-tick execution from 10 to 10,000 robots. Reproduce any run exactly — no GPU, no cluster.

      • Seeded & reproducible
      • Up to 10k robots
      • Browser-native
    • Failure-injection benchmarks

      Stress topologies with packet loss, robot dropout, and link latency, then measure how gracefully coordination degrades.

      • packet_loss
      • robot_failure
      • link_latency
    • SDK — Python, C++, ROS2

      Take the exact graph you designed in Studio to the field. Python, C++ (pybind11), and a ROS2 bridge are being built on one shared core.

      • Python SDK
      • pybind11 bindings
      • ROS2 bridge
    • Live metrics & convergence

      Track average path length, clustering, disagreement, and message volume in real time — the numbers that prove a swarm is coordinating.

      • Convergence curves
      • Path-length tracking
      • Streaming telemetry
    • 10,000+

      Robots per simulation

      Discrete-time, deterministic

    • 4

      Topology families

      incl. Spatial Small-World

    • 7

      Coordination policies

      Consensus · allocation · flocking

    • 96%

      Fewer messages

      vs. full mesh — sample simulation

    Benchmark suite

    Reproducible by design

    Every topology is scored on a reproducible benchmark: how many ticks to reach consensus, and how many messages it costs. In our simulations, small-world graphs converge about as fast as a full mesh while sending a fraction of the traffic.

    • Seeded runs — anyone can reproduce the exact result.
    • Built to rank reference and community submissions side by side as the beta opens.
    • Scored under failure injection, not just ideal conditions.
    Explore the leaderboard

    Convergence leaderboard

    ticks · lower is better

    Sample benchmark data (simulation)

    1. 1Small-World 100 (β=0.12)128watts_strogatz400 msg/tick
    2. 2Full Mesh 100160k_regular9,900 msg/tick
    3. 3Scale-Free 200186barabasi_albert720 msg/tick
    4. 4Star 100220k_regular198 msg/tick
    5. 5Spatial SW 1k412spatial_small_world4,000 msg/tick

    Build your first swarm in minutes.

    Drop nodes on a ring, tune the rewiring probability, pick a consensus policy, and hit run. No install, no GPU, no cluster — then export the same graph to your robots.

    Launch the StudioRead the SDK docs
    Spatial Robotics