Connect your org · Edition 2026.06

Install on your org, then read your atlas from Claude.

PlatAtlas unifies your equipment and your work into one queryable atlas. The preferred way to use it is from Claude Desktop or Claude Code over MCP — on your Claude subscription, which costs far less than per-token API billing. Everything lives at platatlas.com/console; there are no per-org subdomains.

One host, no subdomains. Your org is selected after you install the App — the console is always platatlas.com/console, and example atlases open at platatlas.com/?atlas=…. There is no <org>.platatlas.com.

01Install PlatAtlas on your GitHub org

PlatAtlas authenticates by installing a GitHub App on your organization — that's how it knows which org is yours and what it may read. Start here:

open https://platatlas.com/console

First visit sends you through Install on your org (platatlas.com/auth/github/start). Approve the App for the org you want to map. Returning users sign in at platatlas.com/auth/github/login. After install you land back on platatlas.com/console with your org selected — no subdomain, no separate instance to provision.

02Read it from Claude — on your subscription (preferred)

The everyday way to use PlatAtlas is to let Claude read your atlas over MCP. Both hosts below run on a Claude subscription (Pro / Max) — for interactive reading and planning this is dramatically cheaper than paying per token through the API. Pick the host you already use:

Claude Code — the fastest start (zero-install plugin)

In any Claude Code session:

/plugin marketplace add RobotRegistryFoundation/claude-code-plugins
/plugin install platatlas@robotregistryfoundation

Restart Claude Code. The /platatlas:* commands appear and a bundled, zero-install MCP server (platatlas) auto-registers — no binary to build, no config to edit. This is the quickest path on any machine, including a Raspberry Pi.

Claude Desktop — the richest experience (atlas rendered inline in chat)

Claude Desktop supports the MCP Apps iframe contract, so your atlas renders inside the chat. Register the platatlas MCP server in your Claude Desktop config:

Platform	Config file
macOS	`~/Library/Application Support/Claude/claude_desktop_config.json`
Windows	`%APPDATA%\Claude\claude_desktop_config.json`
Linux	`~/.config/Claude/claude_desktop_config.json`

{
  "mcpServers": {
    "platatlas": {
      "command": "/absolute/path/to/platatlas",
      "args": ["mcp", "--meta", "/home/<you>/.platatlas/meta"]
    }
  }
}

Restart Claude Desktop and run /mcp — platatlas should show status: ready. The server exposes read tools (list_orgs, list_atlases, get_atlas, view_atlas, query_traces, …) plus one human-gated draft tool; promotion stays in the console.

The one-line installer @platatlas/cli is in flight. Until it ships, the Claude Desktop binary is a source build (

cargo build --release -p platatlas-cli --features
      ui-resource

) for orgs with repo access — so if you just want to get going, start with the Claude Code plugin above; it needs nothing built.

03Bring your machines and AI agents: ROBOT.md + the gateway

Every machine and every AI agent that acts in your org carries a ROBOT.md manifest — its identity, capabilities, and the policy it must obey. This is the critical primitive: it's how PlatAtlas knows what a machine or agent is and what it may do. Generate one without writing it by hand:

open https://platatlas.com/examples/equipment/

Pick real, on-the-market equipment and the picker emits a ROBOT.md to drop at the root of that machine's (or agent's) repo. The rrn is left blank on purpose — RobotRegistryFoundation mints the cryptographic identity at bring-up; the picker never fabricates one.

The ROBOT.md gateway is what enforces it. It's the host gate every proposed action passes through: it signs an action that conforms to the manifest and policy, and refuses one that doesn't — on the device or host, never in the multi-tenant cloud. No conforming ROBOT.md + gateway, no signed action.

04The definitive record: mcp-tape + mcp-replay (built in)

PlatAtlas's answer to "what actually happened?" is a recording, not a recollection. mcp-tape and mcp-replay are PlatAtlas's built-in trace tooling — the way it captures definitive records you (or a third party) can check.

mcp-tape records. It wraps each MCP server in your client config and writes every JSON-RPC frame to JSONL — one file per session. The Claude Code plugin wires this in; nothing leaves your machine until you sync.
mcp-replay replays. The built-in viewer renders any captured trace frame-by-frame; from inside Claude, the query_traces tool reads the same record.
See it for yourself. Anatomy of a checkable action renders a real RCAN signed-action envelope and lets you verify its Ed25519 signature in your own browser — tamper with it and the check fails. (Example conformance vectors, not a record of a real action.)

# Replay a trace in the built-in viewer (no subdomain):
open "https://platatlas.com/replay/?trace=<jsonl-url>"

# Sync local traces to your org's atlas (attributed to your GitHub login):
platatlas sync ~/.platatlas/traces/

Synced traces attach to your org's atlas, private by default. This recorded chain is what turns "the agent says it did X" into "here is the signed frame where it did X" — the definitive answer.

05Authenticate the MCP host once

The first read needs your GitHub identity so traces and views attribute correctly. The Claude Code plugin walks you through this on first use; for the standalone Claude Desktop binary, run the device flow:

platatlas auth --device   # follow the GitHub device-flow prompts

The token lands at ~/.platatlas/auth.json. If a tool ever returns source: unavailable (a 401), re-run it to refresh.

06Open your console and your atlas

Everything is path-based on the one host — no subdomains:

Surface	URL
Your console	`platatlas.com/console`
An example atlas (no login)	`platatlas.com/?atlas=examples/james-mays-farm`
The example field map	`platatlas.com/examples/james-mays-farm/map.html`

Ask Claude "show me my PlatAtlas atlas" and the MCP server returns it — rendered inline in Claude Desktop, or as a browser handoff in Claude Code.

07When you need the API (special cases)

Most orgs never touch the API — the subscription path above covers day-to-day reading and planning. You reach for the API + an sk_live_ ingest key only when an atlas (a GitHub org) needs to:

Push signed traces programmatically — RCAN trace ingest from CI, a server, or robots in the field.
Run managed-agent features server-side — e.g. the autonomous rover / drone coordinator that dispatches and coordinates managed agents, which runs as a service rather than an interactive chat.

Mint the key in the console (org settings → API keys); the sk_live_ secret is shown once. Then point your ingest or coordinator at the API.

Cost note. The API is metered per token and costs materially more than a Claude subscription. Keep everyday reading and planning on Claude Desktop / Claude Code, and use the API only for the ingest and managed-agent features above — that's the cheapest way to run PlatAtlas at scale.

What you get

A queryable atlas of your org — equipment, capabilities, flows, and named milestones — readable from inside Claude.
One host, path-based. platatlas.com/console for everyone; no per-org subdomains to manage.
Subscription-first economics. Interactive use rides your Claude subscription; the metered API is opt-in for ingest + managed-agent features.
Works with any MCP client that reads a standard config — no client lock-in.

PlatAtlas · Edition 2026.06 · Vol. I. Agriculture is the platform's first vertical. Source at github.com/PlatAtlas/workflow-atlas.