Platform · Trust and control

LLMs on the mesh.

Ask an assistant why the drone’s command link moved to the satellite, and it should not have to guess from a screenshot. atlas-mcp gives it the mesh itself, over the Model Context Protocol (MCP): the links, routes, policy verdicts and journal of every node, each fact with the node it came from and how old it is. It reads. It never writes.

ShippedReads only · one opt-in write
The mechanism

It reads the node APIs. A model reads it.

Every node already serves its own state: a snapshot of every link, peer, route, served LAN, traffic class and policy verdict, its event journal and its health. atlas-mcp is a separate program that reads those APIs and answers a model’s questions about them over MCP.

THE NODES · EACH SERVES ITS OWN STATE ATLAS-MCP THE ASSISTANT gsattached · its API on loopbacksnapshot · health · journal · policy dronea member · its API on the tunnelsnapshot · health · journal relay-2a member · its API on the tunnelsnapshot · health · journal loopback API · every 2 s one declared variable, only when you allow it over the mesh · every 10 s read token atlas-mcpruns on gs · reads onlyevery fact: node · recorded at · age MCP tools and resources read Assistantany MCP client atlas-mcp reads; the only path back is the one you open
THE NODESgs, drone and relay-2 each serve their own snapshot, health and journal
ATLAS-MCP ON GSreads gs over loopback every 2 s, and the members over the mesh with the read token every 10 s
THE ASSISTANTany MCP client; its tools and resources only read
THE ONE PATH BACKone declared policy variable, only when you allow it
Reach

One attachment, the whole fleet

Attached to one node, atlas-mcp finds every other member in that node’s fleet view and reads each of them over the mesh itself, with the same read-only token members already use to read each other — it asks each member directly, so no node fans a request out on its behalf.

Cadence

Snapshots, read on a schedule

The node it is attached to is read every two seconds, the members it found every ten, one snapshot each; most questions are answered from the latest snapshot, and the journal and health checks are read when a question asks for them.

Stamps

Every fact says where and when

Every fact carries three stamps: the node it describes, the moment that node recorded it, and its age when the model read it. A node that stops answering keeps its last state, marked unreachable with the reason, and its age keeps growing — the model is never shown an old number as a current one.

Placements

One program. Two places to run it — and only while it is needed.

The same tools in both places. Nothing runs while no one is asking. What a node cannot be read for is said in the answer, never filled in.

WhereHowWhat the model sees
On a member of its ownA small host joins the mesh as a member and does nothing else; atlas-mcp starts when an assistant connects — over SSH, or as a service started for the session — and stops when it is done.The whole fleet, from a member whose only job is to answer.
On a nodeThe assistant on that machine starts atlas-mcp itself.That node, and every member it can reach over the mesh.
What a model can read

Fifteen questions it can answer, and counting. Each answer says how fresh it is.

Each tool answers from the snapshots atlas-mcp holds, and every node in the answer carries its stamps.

ToolAnswers
fleet_overviewEvery node known, its address, release, links alive, sessions, policy mode and the age of its data.
node_statusOne node in full, with its own health checks.
node_linksEach link: alive or dead and for how long, RTT, jitter, loss, capacity, score, queue, probes, relay, the policy’s verdict and the rule behind it.
node_peersSessions per link, and the node’s view of every member.
node_routesEvery route with its origin: a member, a served LAN and whose, a seam import.
explain_linkWhy a link carries or not — the policy explanation for that link.
traffic_classesDrops by class and reason: queue full, deadline passed, refused by record.
policy_stateRules, verdicts, silent links, external variables — fresh or stale — and findings.
journal_searchThe node’s event journal, by time, category, severity, code or text.
dead_link_events, eventsDead links, served-LAN changes and failovers across the fleet.
version_skewThe release and contract numbers of every node, and which differ.
relay_statusRelay sessions, the elected relay, the election’s view.
served_lansLANs served into the mesh, and Interconnect seams.
find_nodeA node by name, id, address or role.

The same facts are resources too — atlas://fleet, atlas://node/<node>/links, atlas://node/<node>/journal?since=2h and the rest — each readable as JSON and as a short text rendering. atlas-mcp speaks the current revision of the protocol and the earlier ones, over stdio or streamable HTTP.

The control rule Shipped

A model reads the mesh. It never writes it.

No tool edits configuration, revokes a node, admits one, pushes a release or rolls one back. That is not a setting: the HTTP client inside atlas-mcp can only read, and only the snapshot, health and journal of a node. Configuration still changes only by a push signed with an author’s key.

The one write

A value the policy already listens for Opt-in

One write exists, for one purpose: an assistant can set a value the operator’s policy has already been told to listen for — an external policy variable such as a posture — through the node’s own telemetry socket, exactly as a program on the vehicle would. It exists only when all of these hold:

  • atlas-mcp was started with --allow-feed — a flag, never a configuration key;
  • the node’s signed record grants it: mcp = ["read", "feed"] — and the node checks that itself;
  • the variable is on atlas-mcp’s own list;
  • the node’s configuration declares the variable, and the value has its type.

The node then applies its own checks, and the value expires after the variable’s declared maximum age unless it is sent again. What the policy does with it is what the operator wrote in the policy. external variables ↗

The record

Granted by the fleet’s author, enforced by the nodes

Whether a model may read a node is written in that node’s signed record, by the fleet’s author, not by whoever starts the program: in a fleet of signed records, the nodes themselves refuse atlas-mcp what the record of the node it runs on does not grant, and say why. Every tool call is logged on the node running atlas-mcp, with its arguments and its outcome — never a credential.

fleet-list.toml — the node’s record
[[node]]
name = "gs"
# …
[node.ext]
mcp = ["read"]          # or ["read", "feed"]; no entry: nothing
A session

What the model sees.

Abridged from a recorded session: two nodes, gs and a drone whose dashboard is closed, one link between them taken down for a moment just before. atlas-mcp ran on gs over stdio. Columns are trimmed and the refusal shortened; the node ids are the recording’s.

a recorded session, abridged
→ fleet_overview
Fleet: 2 node(s) known, 2 answering now · atlas-mcp may read
gs      6af9..5c0b   10.95.0.1   links 1/1  peers 1/1   22 ms old  [attached]
drone   6b99..9647   10.95.0.2   links 1/1  peers 1/1   22 ms old  [discovered via gs]
versions: no skew among the nodes that answered

→ dead_link_events
12:23:19Z  info  link.up    link l0 to peer 1 is alive again after 1s down  [gs]
12:23:18Z  warn  link.down  link l0 to peer 1 declared dead after 3 missed probes  [gs]
drone: refused (HTTP 403): the mesh read token reaches the snapshot and health, not the journal

→ feed_policy_variable  ext.assistant.posture = "quiet"
refused: feeding is off — atlas-mcp was started without --allow-feed, so it only reads

The drone was found through the ground station’s view of the fleet and read over the mesh. Its journal stayed closed, and the answer says why. In a fleet of signed records whose ground station is granted read, the same question also returns the drone’s own link.down and link.up.

Boundaries

Where it stops.

Stated in the same font size as everything above.

Snapshots

It answers when asked

atlas-mcp answers from the latest snapshot it holds; it does not push changes to the assistant as they happen. Ask again, and the answer carries its age.

Its name

The record binds atlas-mcp

The record entry binds atlas-mcp, which names itself on every read and every value it sends; a program that does not is not atlas-mcp, and gets what its credential gets.

Journals

A closed member without records

In a fleet without signed records, a member whose dashboard is closed shares its state over the mesh, not its journal; open its reads or give atlas-mcp an API token for it. In a fleet of records, the grant in the record opens the journals too.

Decisions

It explains; it does not decide

Steering stays with the policy the operator signed.

Request an evaluation

Bring the questions your operators ask.

Tell us what the people running your network ask, and about which nodes. The answer is what atlas-mcp reads for it, and what it is never allowed to touch.