Operations

Run it like you’ll be running it at 03:00.

Every operational surface assumes the worst night of the deployment: configs that can’t brick a remote node, applies that revert themselves, fleets that converge without a controller, and a dashboard that tells the truth. This page is the whole operator story — including the REST API and the full parameter reference.

Canonical path: /etc/atlas/config.tomlRuns air-gapped
Artifacts

One binary per architecture

x86-64 and ARM64 Linux, from datacenter servers down to ~15 g single-board computers. Reference packaging ships alongside: a hardened systemd unit, SELinux policy module, AppArmor profile, and an Ansible role (binary + sha256, optional STIG baseline chaining).

Identity

atlasd keygen and go

An X25519 keypair, a config file, systemctl start. The unit runs unprivileged with two capabilities (CAP_NET_ADMIN, and CAP_NET_BIND_SERVICE for the mesh DNS resolver’s port 53); the daemon warns at load if the config file’s permissions would expose the key.

Schema

Generated from the structs, so it cannot drift

A JSON Schema is derived from the daemon’s own config types — doc comments become descriptions — committed to the repo, served at GET /api/config/schema, and referenced from the example config so TOML-aware editors autocomplete and validate as you type. The dashboard’s form view is generated from the same schema.

Field-aware checks

The mistakes that bite in the field, caught at load

Duplicate bind device+address+port (SO_REUSEPORT would silently load-balance the sockets against each other) · single-IP STUN lists (classification needs two server IPs) · peer endpoints whose address family doesn’t match the link’s bind · relay links missing their server with discovery off · unknown link names in per-link maps · range knobs configured without position prediction (an inert knob is a warning, not a mystery) · malformed CIDRs as hard errors. Typos surface at start, not as silent misbehaviour at the worst moment.

CI-able

config check --json

The daemon’s exact load pipeline without starting the engine: exit 0 = provably loadable (warnings listed), exit 1 = fatal, with a JSON findings mode for scripts. A config edit is proven before any restart window opens.

Secrets

Redacted at the API boundary

GET /api/config returns the real file — comments and formatting preserved — with secret values replaced by a placeholder; validation resolves placeholders against the live file server-side. The browser edits the real config without a private key ever crossing the wire.

Automation

Credentials for the things that cannot hold a passkey

Once a FIDO2 passkey is enrolled, signing in requires a browser ceremony and a physical key — which CI, kiosks and scripted demos cannot perform. Two credentials exist for them. Operator-minted API tokens (atlasd web) authenticate automation against the node’s own API. The mesh node token (atlasd config node-token) is derived from [mesh] mesh_secret, so every member can mint the same one: strictly read-only (GET /api/config, GET /api/stats) and window-limited — it stops being accepted 5–10 minutes after minting, so you mint per run rather than storing it. Disable it per node with [mesh] node_token_reads = false.

Nexus Atlas: Configuration Across the Fleet3:55 · plays from YouTube
Stage

Validate → diff → classify

Staging validates the candidate, computes a unified diff between redacted texts (secrets stay off the wire — a key-only rotation shows an empty diff by design), and classifies hot vs restart. The v1 truth table is honest: nothing is hot yet; every change restarts.

Commit

Deadman marker, in-place restart

The daemon re-validates, backs up the live file, swaps in the staged one, writes a deadman marker, and restarts itself in place — same PID, so systemd never sees a failure. On every boot, before config parsing, an expired marker triggers swap-back: even an unparseable staged file cannot brick the node.

Confirm or revert

Prove connectivity, or go back

After the staged boot, the change commits on an explicit confirm — or automatically the moment a peer session re-establishes (proof the node still has its network). If the window lapses (default 90 s), it reverts and restarts again, recording why. The dashboard shows the countdown and survives the restart gap with a “reconnecting” chip. Proven end-to-end by the apply suite: peers-auto-confirm, deadline revert, fatal-config reject. Measured

The deadman

The change cut the path it travelled on. It came back anyway.

Nobody believes this one until they watch it. Each node arms its own timer against its own deadline on its own disk — there is no coordinator holding a countdown for the fleet, and nothing has to go right for the rollback to happen. Push the change that removes the route your confirmation would have taken, then watch six nodes independently reach the same conclusion.

Six nodes take one pushed change — each arms its own confirm windowSimulation
Push a change
90 sconfirm window each node arms
0 of 6deadman timers running
upoperator session to the fleet
What you’re watching: the line in each lane is the operator’s session to that node — solid while it carries traffic, dashed amber for the in-place restart, dashed red once the change has taken it away. The bar underneath is that node’s own confirm window: 90 s by default, counted against an absolute deadline on its own disk, red in the last fifteen. Time is compressed 10× so a full window fits in the frame. The three changes on offer are real fields with their real defaults, and all three sit inside the section allowlist an epoch is permitted to carry — identity, peers and auth never travel.
Envelope

Ed25519-signed, strictly increasing

Fleet policy travels as a signed envelope — epoch number, author, optional role targeting and minimum daemon version, the policy TOML, the signature over a canonical serialization. Nodes verify against trust anchors on disk and persist a high-water epoch, so replayed or rolled-back envelopes are rejected.

Boundary

The whitelist is a security decision

Policy may carry the sections that should match fleet-wide — scheduler, link monitor, QoS, traversal, the adaptive policy, plus per-role overlays — and nothing else. An envelope smuggling identity, peers, auth or mesh settings is rejected at signing and at verification: knowing the mesh secret means you may see the mesh; holding an author key means you may change its policy; nobody can rewrite a node’s identity remotely.

Distribution

Gossip does the delivery, apply does the safety

Epochs ride the existing encrypted gossip anti-entropy — offline nodes catch up on reconnect — and every accepted epoch runs through the commit-confirmed lifecycle above. Each node gossips its own status back (applied / staged / rejected-with-reason / not-targeted, config hash, version), so the authoring node watches the whole fleet converge from one screen. Authoring: offline CLI signing, or “Push to mesh” in the dashboard. Proven in the epoch suite: propagate, apply, tamper-reject, rollback-reject, recover. Measured

Compare

Any node is the console

There is no controller, so the question “is the fleet actually running the policy I think it is?” is answered from whichever node’s browser you have. GET /api/fleet/configs pulls every mesh member’s config over the tunnels — each peer redacts its own secrets and keeps its own read protection — and the compare view canonicalises them into a skew matrix. The distinction is what makes it readable: policy sections (scheduler, link_monitor, qos, traversal) are the finding; node-local sections (interface, links, peers, mesh) are expected to differ and stay quiet. Redaction placeholders compare equal, so secrets neither leak nor false-alarm.

Consistency

Configs that are wrong about each other

A harder question than “do these differ?”: node A can never know that B forgot to list A back, so a controller-less system cannot detect the mistake locally — by definition. With every member’s config already in hand, the whole relation graph is cross-checked instead: 39 checks covering peering reciprocity, keys that resolve to no node, and the rest, each naming the nodes involved, the exact keys, and what will actually go wrong.

Roles

One epoch, different policy per platform

A node carries a role ([mesh] role), and a signed epoch can target it: [roles.<name>.<section>] overlays apply only to matching nodes, and target_roles decides whether an epoch applies here at all. So one push can tighten the drones’ link monitor without touching the ground stations — and a node with no role is untargeted rather than silently included.

Update classes Shipped

A push never strands an aircraft.

Every node record carries an update class, and a release reads it. Required nodes gate the release: it is not complete until each of them has confirmed, and a required node that fails, or stays silent past the release deadline, aborts it. Best-effort nodes are tracked and never block; they apply when they are next seen. Left-behind nodes are outside the gate altogether and keep their own copy out of the way: they read their class from their own record and do not apply during the rollout, so a node that must stay on a known build can be left where it is, and the matrix shows it as running epoch N−k.

CANARIES GATE RELEASE RELEASE WATCH OUTCOME node-b required · applied node-c best-effort · applied node-h left behind · epoch N−1 outside every gate, not targeted Gate every canary applied Release epoch N+1 to everyone CONFIRMED node-d required · applied node-e best-effort · applied node-g best-effort · pending · listed node-f required · silent at the deadline Complete all required in Abort names node-f abort: the pre-rollout policy signed forward as a newer epoch to everyone, the cause naming the node required best-effort silent or failed
REQUIREDgates the release; silent or failed at the deadline aborts it, and the abort names the node
BEST-EFFORTtracked, never awaited; applies when next seen
LEFT BEHINDoutside every gate, shown as epoch N−k; pinned, it never takes the epoch
The gate

Two gates, and the second one can say no

The canary gate is unchanged: a release needs every canary applied. The release now opens a watch of its own, with a deadline of three confirm windows plus two minutes unless the rollout, or the fleet's configuration, sets one, and joins the targeted set — roles and nodes, minus the left-behind — against the status every node gossips back. When the last required node has confirmed, the rollout is complete; the best-effort nodes still on their way are listed, not waited for. A required node that rejects the epoch aborts the release at once. A required node still unconfirmed when the deadline passes aborts it then. A required canary that is silent past the canary deadline aborts the rollout in the canary phase, where today it would only expire.

The abort

Automatic, and it says which node

An abort is the pre-rollout policy signed forward as a newer epoch to everyone the release reached, so the fleet converges on the baseline rather than being left half-applied. The rollout record keeps the cause — the node and whether it was silent or failed — and the matrix, the CLI and the journal (rollout.auto_abort) all carry it. Nothing new enters the envelope: classes live in the node record, not in the signed bytes, so an epoch is the same bytes whatever the classes of the fleet.

Left behind

Excluded on the receiving side

A left-behind node holds the envelope for anti-entropy so its neighbours still catch up through it, records its own state as left behind, and does not stage or apply while the rollout runs. Unpinned, it takes the newest epoch after a grace of ten minutes from first sight, so it catches up late and never during the watch; pinned, it never takes it. Either way the matrix shows it as running epoch N−k rather than as a node that failed.

Operator

Class per row, gate in the header

The Fleet view gains a Class column and, during a release watch, a split of the required nodes still to confirm above everyone else; the header shows the release gate and a countdown to its deadline, and an abort cause when there is one. Set class is an action on the row, signed into the fleet list like any record change. On the CLI, atlasd fleet set-update-class writes the record and atlasd fleet rollout status prints both gates. the live view ↗the node record ↗

Rotation Shipped

Keys change without a flag day.

A node's transport key, its signing key and the fleet's shared mesh secret rotate on one schedule carried in the signed fleet list: publish, when every node starts accepting the new material beside the old; activate, when the new material is used for sending; retire, when the old is refused. The windows are set per fleet — an hour's notice to activate by default, and the retire step offered a week later — and a rotation can run for one node, for the secret, or for several at once. A node acts on the schedule it holds and the clock it trusts, so the whole fleet never has to be reachable at the same moment.

ONE SCHEDULE · A NODE KEY, A SIGNING KEY OR THE MESH SECRET OVERLAP · BOTH ACCEPTED old key accepted until retire lifeline bootstrap peers new key accepted from publish · used for sending from activate node-k offline · back inside the window receives the schedule over its first session and switches by itself node-m after lifeline Refused re-enrols PUBLISH accepted everywhere ACTIVATE used for sending RETIRE signed only once every required node reports active defaults: publish → activate 1 h · activate → retire 7 days · lifeline 24 h after retire
PUBLISH → ACTIVATE → RETIREnew material accepted first, then used, and only then is the old refused
BACK INSIDE THE WINDOWa node receives the schedule over its first session and switches on its own
BACK AFTER RETIRErefused everywhere once the lifeline window closes; it re-enrols through admission
Material

Over sessions, never in gossip

A rotation is a schedule object in the fleet list, signed with it. For a node key it names the next key; for the mesh secret it carries the new secret sealed to each recipient's current transport key. The list travels only over authenticated sessions, so a node still on the old secret receives the new one through a session it already has, and a node a hop behind is heard under the old secret until the list reaches it. Peers accept a node's current and next key at the handshake; at activate the node initiates with the next key and its peers re-handshake make-before-break with the same node id, so routes and topology do not move. A signing-key rotation is scheduled, gated and retired the same way; its subject signs with the next key once its config carries it as the node's signing key, applied like any config change. names, not keys ↗

Retire

Gated on the nodes that matter

Retire is a signed step of its own, never a timer. The operator's node computes the retire gate from the status every node gossips: every required node — and, for a node key, its subject — has reported the rotation active; best-effort and left-behind nodes are listed, not awaited. Until then nodes treat retire as never, and atlasd fleet rotate retire and the dashboard button refuse — unless forced, with an audit entry. The figure the dashboard shows, "N nodes still on the old key", is true because it is read from the nodes themselves.

Lifeline

The last to let go

Retire reaches ordinary members first; the bootstrap peers flagged as lifeline keep answering old material for one more window, a day by default. A straggler that was away through the whole rotation still finds a bootstrap peer that speaks its key, receives the list through it and switches. After the lifeline window it finds nothing: a node holding only retired material is refused at every handshake, its own dashboard says which rotation it missed, and it comes back through admission with a new token. There is no back door by design. Only retired keys are refused: a node that missed a mesh-secret rotation but still holds a valid transport key is let in, takes the list over that session and catches up. admission ↗

Clock

Scheduled, or on receipt

Activation can be set for a time. A node whose clock is disciplined by NTP, PTP or GPS acts on it at that time; one without a trusted clock activates on receipt and says so in its journal. A rotation can be cancelled before activate, and every node stays on its current material; after activate only the signed retire step ends it.

Nexus Atlas: Fleet View and Versioning1:36 · plays from YouTube
One pass

Describe the mesh, download the bundle

atlasd config wizard serves the dashboard SPA loopback-only with an authoring API: describe the subnet, nodes, links and roles once, and the bundle builder emits a complete per-node config set — fresh X25519 identities, the full peer cross-graph, shared mesh secret, optional epoch-author kit and install notes — zipped deterministically with tight permissions on the secret-bearing files.

Self-checking

Every generated file passes the daemon’s own validation

A fatal finding in a generated config is treated as a wizard bug, not a user error; a preview mode returns the whole plan first, and minted keys round-trip so the reviewed text and the downloaded zip are byte-identical. Provisioning a five-node mesh is one wizard pass and five file copies.

The configuration assistant4:06 · plays from YouTube
The dashboard

Every node serves its own truth.

Ten tabs on :9800 — overview, topology, peers, mesh & routes, metrics, scheduler, QoS, enroll, configure, settings, and Terrain on a node that holds elevation tiles — rendered from the same once-per-second snapshot every other consumer reads. These are real captures, not mockups.

Queue

The wait below the tunnel, per link

A link card’s Queue row shows how long a packet sent now would wait before it reaches the device, in milliseconds, and the details dialog breaks it into socket bytes, device-queue bytes and device-queue drops. A yellow standing-queue chip marks a link whose queue has stopped draining, and the Scheduler tab shows the same delay beside each link it weighs. the six queues ↗standing queue ↗

Drops

Every drop on a link, by reason

A link card’s Drops line splits what the link discarded by reason — late, queue full, abandoned, abandoned after send — and the QoS tab splits the same figures by class. “Abandoned after send” is the waste figure: airtime already spent on a packet that can no longer arrive, and the one part of the line that turns amber. the reasons ↗

Terrain

The ground under the fleet, in 3D

On a node with [terrain], a Terrain tab draws the node’s own elevation grid with every positioned node at its real position and every link coloured by line of sight, the worst obstruction and the reroute marked on a shadowed path, and a per-neighbour table of risk, clearance, Fresnel obstruction and diffraction below. Nothing is fetched from outside the node. the 3D view ↗

Propagation Shipped

Watch the change reach every node.

A push spreads by gossip, neighbour to neighbour, with no controller in the middle to report back. So every node records where its copy came from — the neighbour whose gossip delivered the epoch, and when — and gossips that back with its status. The node that pushed reads those answers as a picture of the push in motion.

PUSHING NODE HOP 1 HOP 2 HOP 3 node-a signed the push · applied node-b applied · via a node-c applied · via a node-d applied · via b node-e applied · via c node-f applied · via c node-g pending · via d node-h silent holding the release applied pending silent the push, along the link that delivered each copy
EACH NODE SAYSwhich neighbour delivered its copy, and when it arrived
THE PUSHING NODE SEESthe push travelling hop by hop, every node tinted by its state
THE SILENT NODEnamed in the matrix, and holding a canary release until it answers
Dashboard topology with Propagation on: a legend with a count per push state, the replay scrubber, and twelve nodes ringed by push state, one failed and one marked with an older daemon version
Topology with Propagation on — every node ringed by its push state, the count per state above, the scrubber for replay, and a version chip on the node running an older build.
Configure tab, Fleet view during a released rollout: one row per node with its epoch, state, push-state chip, the neighbour that delivered the epoch, when it arrived, daemon version and role, sorted with the failed node first; an archive list below with a replay button
The Fleet view during a rollout — the failed node first, then the ones still on their way; who delivered each copy and when; the archive with replay on the topology.
States

Every node has a state, and the worst come first

The Configure tab’s Fleet view gives each node a push state: applied, awaiting confirm, staged, received, pending, silent, failed, not targeted, or old version for a node below the push’s minimum daemon version. Silent means nothing has been heard from a targeted node past the rollout’s watch deadline. During a rollout the rows sort by severity, and each one shows the neighbour that delivered the epoch and when it arrived. A canary rollout releases only once every canary has applied, so a silent canary holds the release, and the matrix names it. A Class column shows each node’s update class, and during a release watch the required nodes still to confirm sit above everyone else, with the release gate and its countdown in the header. update classes ↗

Topology

The push, drawn on the mesh

Switch the Topology tab to Propagation and each node takes a ring in its push state. A pulse runs along the link each node’s copy arrived on, so the push can be followed hop by hop from the node that signed it; delivered hops stay as faint lines, and the delivery tree still reads once the push is over. A copy that came through a node not on the canvas is drawn as a dashed arc from the pushing node. A version chip marks each node running a different build from most of the fleet. The same overlay shows a rotation in progress: each node ringed by whether it has published, activated or retired the new key or secret, so the nodes still on old material stand out on the map as plainly as a silent node does during a push. signed epochs ↗rotation ↗

Replay

Play it back

A scrubber spans the rollout: play at 1×, 10× or 60×, step from one event to the next with the arrow keys, or snap back to live. The pushing node keeps the timeline and archives each finished rollout, the last fifty of them, so any past push can be replayed on the topology from the Fleet view’s archive list.

Access control: the dashboard has local accounts with optional FIDO2 hardware keys and mandatory-2FA upgrade — the write endpoints demand more than being on the right subnet. Details under security.
CommandWhat it does
keygenGenerate an X25519 keypair for configs
run -c <config>The daemon itself
statusFreshness-checked digest of every instance on the host — one command on a relay shows both interfaces
stats -f jsonOne-shot snapshot dump, scriptable
monitorLive terminal dashboard, 500 ms refresh, sparklines
webREST + embedded dashboard server (plus web adduser · passwd · deluser · list-users · remove-passkey)
enroll <code>Claim this node in the hosted console by proving possession of its key — nothing copy-pasted
config schema · checkPrint the JSON Schema; run the exact load pipeline without starting (--json for CI)
config keygen-author · sign-epochMint an epoch-author key; sign a policy TOML into an epoch envelope, offline
config wizardThe offline provisioning shell (loopback-only unless explicitly overridden)
fleet set-update-classMark a record required, best-effort or left-behind (--pinned never takes a new epoch) in the authoring list, ready to sign and push
fleet rollout status · release · abortThe rollout this node drives: both gates, every node’s class and state; sign the release or the abort from a terminal
fleet rotate plan · status · activate · retire · cancelSchedule a key or mesh-secret rotation, read every node’s rotation state and the retire gate, bring activation forward, sign the retire step (refused until the gate passes), or withdraw before activate
fleet set-lifelineFlag a bootstrap peer as a lifeline in the authoring list: it keeps answering retired material for the lifeline window
REST API

The same truth, over HTTP.

Same-origin, gzip, session-gated writes (?interface= selects an instance). The daemon’s own consumers use these endpoints — there is no second, better API.

GET/api/stats

The live snapshot: links, peers, routes, topology with positions, crypto posture, QoS counters, bonding tax.

GET/api/interfaces

Every daemon instance on the host.

GET/api/scheduler-log

Recent scheduler decisions — timestamp, strategy, chosen links, costs. “Why did it pick the serial radio there?” is answerable after the fact.

GET/api/qos

Live class policy + per-class counters and escalation state.

PUT/api/qos

Merge-update the policy at runtime — no restart.

GET/api/netcheck

Per-link public endpoints and NAT classification from the last netcheck.

PUT/api/position

Operator position inject — persisted, validated, picked up within an advertisement tick.

GET/api/config · /api/config/schema

The live TOML (secrets redacted, comments preserved) and its schema.

POST/api/config/validate · stage · commit · confirm · revert

The commit-confirmed lifecycle, exactly as described above.

GET/api/config/apply-status · /api/config/epoch

The apply state machine the countdown UI polls; the current epoch envelope + per-node fleet status.

GET/api/config/rollout · /api/config/rollouts

The live rollout with both gates — the canary gate and the release gate with its required, confirmed, silent and failed counts, the deadline and an abort cause when there is one — plus the timeline; and the archive of past rollouts. update classes ↗

POST/api/config/rollout/start · release · abort

Start a canary rollout (release_watch_secs sets this rollout’s release deadline), sign the release, or sign the baseline forward. An abort may also end a released rollout still waiting on a required node.

POST/api/fleet/update-class

Set a record’s update class and sign the next fleet list with this node’s config-author key (409 without one). A write-scope token may call it.

GET/api/fleet/rotations

Every rotation schedule with its three instants, each node’s reported state for it, the retire gate, and the nodes still on the old key or secret. rotation ↗

POST/api/fleet/rotations · /api/fleet/rotations/<id>/activate · retire · cancel

Plan a rotation (kind, subject, windows) and sign it into the list; bring activation forward; sign the retire step, refused while a required node has not reported active unless forced, which is recorded; cancel before activate. These take a session; a write-scope token reaches only update-class.

POST/api/config/push

Sign the live file’s policy sections as the next epoch and hand it to gossip (409 with a hint when no author key exists).

GET/api/admission · /api/admission/pending · /api/admission/invites

Who is knocking, who is blocked, the open invitations and who used them, the records held outside the signed list. admission modes ↗

POST/api/admission/invites · approve · deny · unblock

Mint a pairing code, decide on a knocking key or a record another node forwarded, lift a block — callable with a write token, so a platform backend runs admission without a human session.

POST/api/fleet/revoke

Preview, then sign and push a removal: the records revoked, the mesh secret rotated, the list flooded. removal ↗

POST/api/fleet/select-area

A polygon in, the review out: the records whose last advertised position lies inside, each with the age of its fix, a count of those outside, and the records with no position. Selects only; the removal is /api/fleet/revoke. removal by area ↗

POST/api/fleet/zeroize

Preview, sign and push a remote zeroize for one node, held until a set time if asked, or cancel a pending one. The command also revokes the node. Signs with this node’s config-author key and refuses the node it runs on. All three fleet writes take a write-scope API token as well as a session. remote zeroize ↗

POST/api/auth/login · logout · webauthn/*

Session and FIDO2 ceremonies for the dashboard’s local accounts.

Adapter ingest

The telemetry socket

A Unix socket where adapter processes inject newline-JSON: per-link radio telemetry (RSSI local/remote, noise, TX buffer, error counters) and node position fixes. Crash-resilient, and the daemon never depends on it — telemetry loss can never back-pressure a data path. the adapters ↗

Measured

The bonding-tax ledger

The first steady-state question every datalink engineer asks — “what does bonding cost me?” — answered by the daemon about itself, continuously: five sampled one-way series (TX pipeline, TX queue wait, RX pipeline, reassembly wait, and the scheduler’s path-choice penalty) with p50/p95/max and added-jitter digests. Every series is reproducible from /api/stats. Measured from outside, on two laptops over a 100 Mbit/s link, Atlas adds 0.006 ms one way over the bare link, against 0.277 ms for kernel WireGuard. The panel footnotes the two things internal clocks can’t see: the 72 B/packet wire overhead and the remote node’s receive half.

Hosted console

Fleet view without inbound access Live service

An enrolled node self-reports per-link health (~every 30 s, on by default, opt-out) to console.nexusatlas.net: honest states, EWMA RTT, loss, byte counters — and fields with no genuine source are omitted, never fabricated. Enrollment is a one-time code plus cryptographic proof of key possession; the console adds orgs/projects/roles, a live map, offline alerts with recovery notices, an audit trail and FIDO2. The console is optional: lose it and you lose nothing but the map.

NMS

Prometheus, without a second agent

GET /metrics renders the snapshot the daemon already publishes as Prometheus/OpenMetrics text: atlas_link_up, atlas_link_rtt_seconds, atlas_link_loss_ratio, atlas_link_jitter_seconds, atlas_link_quality_score, per-link byte and probe counters, atlas_peer_session_established, atlas_qos_{enqueued,sent,dropped}_packets, the bonding-tax percentiles and the metered-link budget series. It is a formatter over the stats file, not a second collection path — no exporter process, no agent to keep alive on a node you cannot reach — and atlas_scrape_duration_seconds reports what the formatting itself cost. On by default at /metrics; [metrics] enabled = false answers 404.

SIEM

Syslog and CEF, event-shaped

[syslog] ships state changes rather than log lines — a link going down, a peer session tearing down — to a collector over UDP, TCP or unix:///dev/log, as RFC 5424 structured syslog or ArcSight CEF. Facility, minimum severity, hostname and SD-ID are yours. The queue is bounded: a collector outage drops and counts events rather than back-pressuring the daemon. Opt-in, and separate from [logging], which is verbosity for humans.

Liveness

A health check that fails when the data path does

“The process is up” is the check every monitoring system does by default and the one worth the least here: atlasd can be running, answering HTTP and carrying nothing — TUN gone, links dead, engine loop wedged. GET /api/health answers three questions separately: is the daemon alive (stats snapshot fresh), is the data path serviced (watchdog counters advancing, TUN present, probe loop running), and is anything reachable (a link answered a probe recently). Only the first two can fail the check — a node whose peer is legitimately offline is a healthy node with nothing to talk to, and a check that pages on that is a check that gets muted.

Fleet

Is the fleet healthy, asked from anywhere

GET /api/fleet/health is a daemon route rather than a browser loop for a specific reason: the dashboard is same-origin only, with no CORS, no peer registry and no way to attach the mesh read token. The daemon has all three. One request, one answer for the whole mesh, from any member.

Escalation

One zip, redacted by allowlist

atlasd support-bundle, or one button in the dashboard: config, stats, health, the event journal, the scheduler log, netcheck results, versions and the crash spool, collected once instead of over a dozen round-trips. The config is rewritten through a deny-by-default allowlist, so private keys, the mesh secret and auth credentials never leave the node — and neither does any key this build does not recognise. Topology is included deliberately: a bundle with half a topology cannot be diagnosed from. Treat the file as sensitive.

Crashes

A crash that reports itself — or doesn’t

A panic or a fatal signal is captured in the dying process, redacted at capture (private keys, session keys and the mesh secret are never written down in the first place), and spooled on disk under hard bounds. Nothing in the capture path opens a socket: upload is a separate decision and auto_send is off by default. Three ways out, for three realities — attributed, anonymous, or via a peer for a radio-only node that cannot reach the internet at all, where a mesh member that can forwards the payload without being able to file under its own identity. Reports group by a blake2s fingerprint of the normalised top frames plus the panic message, so one bug is one group and not fifty. Coredumps are opt-in and require a public key: they are encrypted or they are not written.

Nexus Atlas: The Console3:07 · plays from YouTube
Assistants

What an assistant reads.

The snapshot, the journal and the health checks behind the dashboard are what atlas-mcp reads from every node, and it answers an assistant’s questions about them over the Model Context Protocol: fifteen read-only tools, each fact stamped with the node it came from and how old it is. No tool edits configuration, admits or revokes a node, or pushes a release. It runs on a member of its own or on a node, and only while someone is asking. atlas-mcp ↗

The MCP server4:00 · plays from YouTube
Reference

The full parameter surface.

Defaults in parentheses. This is the complete top-level map — the schema (and your editor, via the schema) carries every field’s documentation.

All configuration sections, one table+
SectionWhat it configuresKey parameters (defaults)
[interface]TUN identityname · address · private_key · listen_port · mtu (1416) · node_name · position · endpoint_roaming (true)
[[link]]One underlay linkname · bind_device · bind_address · weight (1) · capacity (80 Mbps) · probe_interval_ms · max_range_m · range_warn_m · type (direct|relay) · relay_server · relay_pubkey · listen_port · pace_framing_bytes
[[peer]]A peer and its routespublic_key · endpoint[] · endpoint_per_link · allowed_ips[] · persistent_keepalive
[crypto]Session lifetimerekey_interval_secs (120) · rekey_data_limit (1 GiB) · disable_encryption (false — testing only)
[auth]Unknown-key policyprovider (static) · keyfile · command · deny_cache_secs (30) · command_timeout_ms (5000)
[scheduler]Strategy + thresholdsstrategy (lowest_delivery_time) · redundancy_factor (1) · priority_order · adaptive_* ratios · loss_* pct (20/50) · latency_* ms (40/100) · adaptive_dwell_ms (5000) · data_loss_probe_every_n (10)
[policy]Adaptive policyenabled (false) · tick_ms (500) · mode (normal) · [[policy.link]] name · tags · [[policy.rule]] name · when · actions · for_ms · hold_ms · script · script_max_operations (200000) · script_time_ms (20) · script_stale_ms (5000) · record (false) · record_interval_ms (1000)
[link_monitor]Probing + predictionprobe_interval_ms (250) · dead_probe_count (5) · prediction_source (none) · rssi_floor_dbm (−88) · rssi_lookahead_secs (2) · range_warn_m (600) · range_full_m (1000)
[routing]Multipath + pinned pathspath_redundancy (1) · [[routing.static_path]] name · path_id · hops[]
[mesh]Control planeenabled (false) · mesh_secret · bootstrap_peers · gossip/heartbeat/expiry intervals · role · gossip_v1_compat (false)
[qos]Transport classesenabled (false) · backlog_bytes (4 MB) · deadline_k (3.5) · floor/ceil (80/1000 ms) · fec_enabled (false) · fec_block_packets (8) · bundle_backend (memory) · rx_release_buffer (false)
[traversal]NAT traversalenabled (false) · stun_servers · netcheck_interval_secs (300) · punch (true) · discover (true) · region · relay_paths (1) · auto_relay (false) · directory (= auto_relay) · directory_slots (2) · federation (false) · federation_allow_plain (false)
[config_mgmt]Fleet pushesrelease_watch_secs (0 = 3×confirm_secs + 120) · left_behind_grace_secs (600)
[rotation]Key + secret rotationdefault_publish_to_activate_secs (3600) · default_activate_to_retire_secs (604800) · lifeline_secs (86400) · require_trusted_clock_for_scheduled_activation (true)
[telemetry]Adapter socket + consoleenabled (false) · socket_path · console_report (on, opt-out) · console_url
[logging]Verbositylevel (info) — journald/syslog via tracing
Boundaries

Operator honesty, itemised.

Three behaviours that are deliberate and worth knowing before the first apply.

Nothing is hot yet

The v1 apply lifecycle restarts on every committed change — even a knob the QoS reload path could technically hot-apply. Deliberate: one lifecycle, one guarantee, no “which kind of change was that?” at 03:00.

Secret edits look empty

Diffs are computed between redacted texts by design, so a private-key rotation shows “no visible changes”. The apply is still real; the emptiness is the proof the secret never crossed the wire.

Auth changes the API contract

Once dashboard users exist, endpoints that used to be open writes — QoS apply, position inject, config — require login. Scripts speaking to :9800 must authenticate, or stay on nodes with no users configured.

Request an evaluation

One binary. One file. One screen.

Running Atlas is deliberately boring: install it, validate the file, watch the dashboard. The interesting parts happen to your traffic, not to your evening.