RUTLI Become a Founding Node

How Rutli works

A network of machines that never stop being yours.

Rutli coordinates capacity. It does not need to own the machines. A node can run useful AI locally, expose only the resources its owner authorises, accept compatible network workloads, and give way when the owner's own work needs the hardware.

Cooperation without surrender.

One node. Two planes.

Your private plane: your documents, your business data, your home, your files, your credentials, your private model memory, your application state. Yours. The network plane: authorised workloads, sandboxed execution, metered resources, only the capacity you choose to expose. Shared by policy. The existence of distributed compute must never mean private application data is automatically scattered across third-party machines.

The private plane. Yours.

  • Your files, your records, your books
  • Your local knowledge and your agents' memory
  • Your home and business telemetry, audio, video
  • Your credentials
  • Anything that needs local inference

The network plane. Shared by your policy.

  • Sandboxed workloads, signed and verified
  • No access to the host's files
  • Limited to the resources you set
  • Interrupted at once by anything of yours
  • Attested where the hardware allows

Sovereignty at three scales: a person's machine, an organisation's building, a region's capacity. The same line runs through all three.

The network shares capacity. It does not acquire the owner's private environment.

PLANNED

The basic flow.

  1. 01

    Your node reports what it can do

    Hardware capability. Available resources. Policy.

    PLANNED
  2. 02

    You decide what is shareable

    Contribution on or off. Schedules. Limits. Allowed workloads. Priority.

    PLANNED
  3. 03

    Rutli matches compatible work

    The network coordinates jobs with machines able and willing to run them.

    PLANNED
  4. 04

    The job runs and is metered

    Usage is measured. The correct owner is credited.

    PLANNED
  5. 05

    Your own work can take over

    Local priority is not marketing copy. It is an operating rule.

    LIVE

Local priority, drawn.

A task of the owner's preempts network work immediately; the job is built to be interrupted and resumed on another node.

A timeline: a network job runs on your machine, you start a game, the job is interrupted at once and resumes on another machine, your game never waited. Your machine Another node network job your game, your render, your inference you sit down: the job stops here, at once the same job, resumed The rule is in the node, not in a setting: a task of yours preempts network work immediately, and the job is built to be interrupted and resumed.

LIVE proven on the founder's machines

Homogeneity belongs in a data centre. Rutli has to work across ownership.

Different GPUs. Different memory systems. Different operating systems. Different applications. Different owners. Different contribution policies. The real world is messy. That is why orchestration matters.

Start with three machines.

The first meaningful Rutli proof is not "one million nodes". It is a much harder and more useful question: can independently owned, heterogeneous machines cooperate without ceasing to be independent?

  1. 0001 A GPU server in the founder's house running LIVE
  2. 0002 A 128 GB Mac on the same network running LIVE
  3. 0003 A collaborator's Mac, behind a home router joins when the node app ships PLANNED
  4. 0004 A node in Italy open PLANNED

None of these machines belongs to Rutli. Rutli coordinates only the capacity each owner chooses to share.

What the proof must demonstrate, item by item, labelled as it stands today.

  • Node registrationPLANNED
  • Capability and availability reportingPLANNED
  • Remote workload execution across nodesPLANNED
  • Metering and correct owner attributionPLANNED
  • Contribution on/off, schedules, resource limitsPLANNED
  • Local priority on the founding machinesLIVE
  • Private plane and network plane isolationPLANNED
  • The contribution dashboard and the balancePLANNED

Today, two of the founder's machines route inference between them with fallback and local priority. That is LIVE . Registration, metering, attribution and the rest are planned and will turn to LIVE one at a time, on the status page.

Why not one giant shared mind?

Because that is not the architecture. Rutli is a federation of intelligence. Different nodes may run different models, different applications, different policies, different hardware, different local data, different priorities. They cooperate when cooperation is useful. They remain autonomous when it is not.

Strong alone. Stronger together.

Become a Founding Node Develop on Rutli