Shareable NixOS

The ALINA desktop, on every teammate's laptop.

ALINA OS is declared in text, but until now that text described one person's machine: their user, their accounts, their secrets. The configuration now separates what a team shares from what one person decides, so a teammate can run the same agentic desktop on their own NixOS laptop, with their own identity and their own keys.

starter · released in openclaw-nix 2026.10.3-r4team layer · in progresscollaboration · planned

The layers

Four layers, one test for each.

Every setting lands in exactly one layer. The test is simple: would a teammate keep it, replace it, or is it only true of this one machine?

Personal

You

Login, name, email, SSH keys, subscription sign-ins, secrets, personal projects and the apps only you chose. Test: a teammate would replace or delete it.

your flake

Machine

This laptop

Hardware, disks, host name, monitors, and single-owner duties such as backups or a relay that only one host in the fleet should run. Test: it's true of this machine and no other.

your flake

Team

What everyone shares

The desktop, tooling, agent roles, skills, plugins, policy and shared services. Test: every teammate's laptop should get it unchanged.

team repo

Product

openclaw-nix

The agent gateway built from source for each release, NixOS and Home Manager modules, the starter and the doctor. Public and MIT-licensed.

public

Start

One command writes your flake.

Run it on the new laptop, as the person who will use it. It asks only what that person decides: their user and full name, the machine's name and time zone, the model provider, and whether they sign in with a subscription or an API key.

Pinned to a release. The generated flake pins openclaw-nix to its newest release tag. nixpkgs, Home Manager and sops-nix follow it.
Secrets never pass through the command line. A provider key comes from a hidden prompt or stdin and is written only in encrypted form.
Team templates. --template generates from a team's own flake, which layers shared agents, skills and policy over the product.

a new teammate's laptop

$ nix run github:alinaos-org/openclaw-nix#init \
    -- ~/laptop
  user, full name · machine name, time zone
  model provider  · subscription or API key
✓ wrote flake.nix host.nix openclaw.nix
✓ secrets/openclaw.yaml encrypted for this machine + you

Next, in ~/laptop:
$ sudo nixos-rebuild switch --flake .#ada-laptop
$ openclaw models auth login \
    --provider anthropic --device-code
$ openclaw-doctor

Illustrative session; the commands are the ones init prints.

Generated file	Layer	What it holds
`flake.nix`	machine	openclaw-nix pinned to its newest release; nixpkgs, Home Manager and sops-nix follow it
`host.nix`	machine	The machine and its user
`openclaw.nix`	personal	The agent gateway as a user service, and its secrets from sops-nix
`openclaw/main.json`	personal	The gateway config. Secrets appear only as `${VAR}` references
`secrets/openclaw.yaml`	personal	A generated gateway token and the provider key, encrypted
`.sops.yaml`	personal	Who can decrypt: this machine's SSH host key and the person's own age key
`hardware-configuration.nix`	machine	From the installer, or generated on the spot

The secrets contract

A missing secret fails the build, by name.

The required secrets are derived from the configuration itself: every bare ${VAR} reference and every environment SecretRef, plus the gateway's own token. The template renders the gateway's environment file from that list, so a reference without its key never reaches a running machine. The build fails and names the key.

Never shared

Sign-ins belong to people.

Subscription logins for Claude, ChatGPT and Gemini, and chat accounts such as Slack and Discord, are personal and can't be shared. After the first switch, each person signs in with their own account using a device code.

Encrypted at rest

Two keys can open them.

Personal secrets are encrypted with sops for exactly two recipients: the laptop's SSH host key, so the system can start, and the person's own age key, which they back up.

The doctor

After the switch, one command checks the rest.

openclaw-doctor runs as the user and checks every gateway on the machine. Each failure comes with its fix.

Environment. Each required variable is set, not empty, and not a placeholder.
Gateway. The service is active and its readiness check answers.
Secrets. OpenClaw's own secrets audit finds no plaintext and no unresolved references.
Models. Each default route has a sign-in or a key.

It names variables, never values, and masks any fragment of a secret in OpenClaw's own output.

openclaw-doctorHEALTHY

ok   main: environment: 2 required set
ok   main: gateway: openclaw-gateway-main.service
        active, ready on port 18789
ok   main: secrets: no plaintext secrets,
        every reference resolves
ok   main: models: 1 route(s) signed in
all checks passed

openclaw-doctor · a key removedFAIL

FAIL main: environment: ANTHROPIC_API_KEY not set
       fix: add it to the secret behind the env file
       (starter: `sops secrets/openclaw.yaml`,
       key anthropic_api_key), then rebuild
1 problem(s)

Output format as shipped; values illustrative.

Tested like a product

Every change boots a fresh laptop.

On every change to openclaw-nix, CI generates a laptop with init and evaluates its whole NixOS system for both sign-in modes. Then it boots one in a virtual machine and checks it.

Scoped secrets

sops-nix renders the environment file for that user alone.

Clean configs

No secret appears in any generated config.

One token

The gateway accepts the generated token and no other.

Honest doctor

It passes on a healthy laptop and fails, naming the variable, once a key is removed.

A teammate's flake

The team is just an input.

A teammate's flake is short. The team repository supplies the laptop builder and pins the product. The teammate supplies their hardware, their host, their personal file and their gateway. ALINA's own reference machine is moving onto the team layer the same way, as one more consumer of it.

flake.nix · a teammate

{
  inputs = {
    team.url = "github:your-org/your-team";
    nixpkgs.follows = "team/nixpkgs";
    openclaw-nix.follows = "team/openclaw-nix";
  };
  outputs = {team, ...}: {
    nixosConfigurations.ada-laptop =
      team.lib.mkLaptop {
        modules = [
          ./hardware-configuration.nix  # machine
          ./host.nix                    # machine
          ./personal.nix                # you
          ./openclaw.nix                # you
        ];
      };
  };
}

Next: working together. One gateway per person, federated over a team relay; a shared work board for Dark Factory runs; and a team scope in shared memory. It comes with rules for whose agent may instruct whose, what may be shared, and how access is audited and revoked.

Try the product layer today.

The starter, the modules and the doctor are public in openclaw-nix. The ALINA team layer is private while it's being separated out.

openclaw-nix on GitHub Next: Loom