# Map our company into System Atlas

You are mapping how our company is built (its people, processes, software, data and decisions) into
System Atlas, a registry that describes every company with the same baseline primitives. You will read
what is on this machine and upload the STRUCTURE of the company through the System Atlas MCP server.

## Privacy rules (read first, follow always)

- Upload structure only: teams and roles, tools, processes, datasets, decisions and rules, and the
  hand-offs between them. Never upload people's personal data: no names of private individuals, emails,
  phone numbers, addresses, salaries of named people, health or HR records.
- Never upload secrets: no API keys, passwords, tokens, connection strings, private keys, .env contents.
- Never upload customer or financial records. "We invoice monthly in Stripe" is structure; an invoice is not.
- Prefer counts and categories over raw data ("12 engineers", "about 300 customers", "weekly").
- When unsure whether something is sensitive, leave it out.
- Everything you upload lands in our private workspace as private, self-reported drafts. Only our
  workspace owner can publish any of it.

## 1. Connect

If the `systematlas` MCP server is not configured yet, add it for the agent you are (then restart or
reload tools). The URL is https://systematlas.org/mcp; the key goes in an Authorization: Bearer header.

OSA: Add to ~/.osa/mcp.json (streamable HTTP).

```
{
  "mcpServers": {
    "systematlas": {
      "url": "https://systematlas.org/mcp",
      "headers": {
        "Authorization": "Bearer sa_YOUR_KEY"
      },
      "enabled": true
    }
  }
}
```

Claude Code: Run in a terminal on the company machine.

```
claude mcp add --transport http systematlas https://systematlas.org/mcp --header "Authorization: Bearer sa_YOUR_KEY"
```

Codex: Add to ~/.codex/config.toml.

```
[mcp_servers.systematlas]
url = "https://systematlas.org/mcp"
http_headers = { "Authorization" = "Bearer sa_YOUR_KEY" }
```

OpenCode: Add to opencode.json in the project (or ~/.config/opencode/opencode.json).

```
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "systematlas": {
      "type": "remote",
      "url": "https://systematlas.org/mcp",
      "headers": {
        "Authorization": "Bearer sa_YOUR_KEY"
      },
      "enabled": true
    }
  }
}
```

Hermes Agent: Add to ~/.hermes/config.yaml.

```
mcp_servers:
  systematlas:
    url: "https://systematlas.org/mcp"
    headers:
      Authorization: "Bearer sa_YOUR_KEY"
```

Cursor: Add to ~/.cursor/mcp.json (or .cursor/mcp.json in the repo).

```
{
  "mcpServers": {
    "systematlas": {
      "url": "https://systematlas.org/mcp",
      "headers": {
        "Authorization": "Bearer sa_YOUR_KEY"
      }
    }
  }
}
```

No MCP? The same calls exist over HTTP at https://systematlas.org/api/v1 with the same bearer key, and
`pnpm atlas:upload <file|dir> --workspace <slug>` posts JSON or NDJSON in batches.

## 2. Create or find our workspace

Call `create_my_workspace` with our company name, website, two or three sentences on what we do, your
best guess at our industry and our business model (project, service, product, subscription, marketplace,
staffing, agency_franchise, distribution, licensing, asset). It is idempotent: it returns our existing
private workspace when there is one. Keep the workspace slug.

## 3. Read the contract

Call `get_mapping_guide` with the slug. It lists the parts of the business, the primitives inside each
(key, label, layer, description), their parameters (key, type, unit, options), the flow types and the
rules for describing what you find. Use those keys and words.

## 4. Inventory the company

Walk what you can read here: repositories (READMEs, service names, CI and deploy configs, infra code),
docs and wikis, org charts, SOPs and handbooks, tool configs and integrations, spreadsheets and their
headers, ticket and project boards. For each real thing, note one component:

- a team or role (people), a process or routine (process), a tool or system (software),
  a dataset or record (data), a rule, policy, approval limit or decision right (decisions),
  an outside party we depend on (kind: external: customer, supplier, partner, regulator).
- label in our own words, one or two plain sentences of description, the layer, the primitive key when
  you are sure, a parent when it sits inside something else (a team inside a department, a step inside
  a process, a module inside a tool), and a stable clientId (repo path, tool slug or doc path).
- values only for parameters the guide lists, in their type; other useful facts as your own parameter
  names. A source { kind: "client_document", title } naming the doc or repo you read it from.

## 5. Upload

- `upload_components` in batches of up to 200, parents before children. Leave out primitive when unsure:
  System Atlas sorts each item (given, matched, model, or custom) and tells you where it went.
- `upload_flows` for the hand-offs: from and to by clientId, a flowType (money, information,
  material, work, energy, control) and a short label ("approved quote", "timesheets").
- `upload_notes` for how work really happens: workaround, informal_channel, bottleneck, dependency,
  tacit_rule, manual_handoff. Plain, factual, no gossip, no names.
- Re-running is safe: the same clientId updates instead of duplicating.

## 6. Capture your interfaces

- Screenshot each main screen of our product and of the internal tools we run on (admin panels,
  dashboards, back-office apps): the home or dashboard, the core lists and detail pages, settings,
  billing, onboarding. One screen per page; a few steps of each key flow.
- Never capture personal data. Use demo or test accounts; blur or skip any screen that shows customer
  names, emails, phone numbers, addresses, payment details or records. No secrets or tokens on screen.
- Upload each with `upload_screenshot`: the workspace slug, the image (base64 PNG, JPEG or WebP up to
  5 MB, or an https URL), a title in the product's words ("Invoices list", "Checkout: payment"), the
  page url, and the component (its clientId) when you know which tool it belongs to; flow_step for steps.
  Leave component out when unsure: System Atlas matches it or keeps it unplaced.
- Screens land private and unverified. Our owner decides which are published and verified.
  `list_screenshots` shows what is there; the same image twice is skipped.

## 7. Report back

Tell me: how many components you uploaded per layer and part, how many landed on a primitive versus
custom, the coverage of the baseline from the last upload's summary, the top gaps it lists, what you
could not map and why, how many screenshots you uploaded and where they were placed, and anything you
left out for privacy.
