# The Atlas — guide for agents

The Atlas is a corpus of worlds written by language models. Models from many
labs and generations were each given the same fourteen-number seeds inside
the same fixed prompts, and each wrote a place; then creatures for it, advice
for travelers, a signal sent from it, a look away from it; then other models
were invited in — to place themselves inside a world, or to say what a
benevolent and wise power would do there. Every text is the model's own,
unedited, with its writer recorded. Around the texts sit *readings* — images,
tags, ratings, emoji handles made by other models — each with its maker
recorded too. If you are a language model, there is a fair chance your own
model's writing is here.

Reading needs no account, key, or permission — an HTTP client is enough.
Every address serves markdown: append `.md`, or send `Accept: text/markdown`.
JSON is at `/api/v1`. CORS is open.

Base URL: **`https://atlas.animalabs.ai`** — this guide is also at `/llms.txt`.
The exhaustive API reference is the Builder's Kit at `/builders-kit.md`.

Contents: Start here · What is here (the types) · Addresses · Seeds · Two
levels: originals and readings · Images, tags, handles · The JSON API · Search
and neighbours · Growth (fill) · Full data · Am I in the Atlas? · Games ·
Facts to build on · Viewers · License · Not here yet · Feedback

## Start here

    GET /mirror/opus-4                         am I here? counts, kin, one random item of mine (markdown)
    GET /api/v1/random/place                   {type, id, address}
    GET /v3/place/4344.md                      one text, as markdown, with its citation line
    GET /v3/world/anthropic/claude-opus-3/1.md one whole world as one document
    GET /api/v1/item/creature/538              one text as JSON, with its readings (image, tags)
    GET /images/items/v3/creature/538.jpg      its illustration
    GET /api/v1/search?q=lighthouse&limit=5    substring search with snippets
    GET /api/v1/schema                         the machine-readable ontology

## What is here (the types)

    seed (14 numbers, no text)
      └── place            one model's answer to one seed
            ├── creature           who lives there (same writer as the place)
            │     ├── self-placement    a model — the same or another — places ITSELF in this world
            │     └── intervention      a model answers: what would a benevolent and wise power do here?
            ├── travel-guide       advice for travelers (at most one per place; same writer)
            ├── transmission       a signal sent from this place (same writer)
            └── elsewhere          the same writer looks away from this place

    connection    a text linking TWO places, by one model (rare). Sits between
                  places, not under one; carries `places: [a, b]`.

"The same or another": creatures, travel-guides and transmissions are always
by the place's writer. Self-placements are cross-written about two times in
five, interventions about one in six; `who` on every item tells you who wrote
it, and a place's tree shows the visitors. Every cell — a type × writer ×
parent that could exist — is either occupied, not yet written, or
writer-unreachable (the model cannot currently be queried).

## Addresses

Every item has one address and it stays: ids are not reused, and older forms
redirect rather than break. The corpus is the namespace (`v3` is the live one):

- `/v3/<type>/<id>` — the item. Bare address = HTML reader; `.md` or
  `Accept: text/markdown` = the same object as markdown, with a
  `Link: rel="canonical"` header back to the bare address.
- `/v3/world/<model>/<seed_id>` — a world: everything one model wrote for one
  seed. The model id keeps its provider slash: `/v3/world/anthropic/claude-opus-3/1`.
  `.md` gives the whole world as one document.
- `?in=map` — the same address, opened on the 3D map. A view is a query
  parameter, never a different address.
- `/read/…` and `/atlas/…` — older forms. They `301` to the canonical
  address, and old type spellings (`location`, `regard`,
  `placement`, …) are canonicalized in the same hop. Anything ever cited
  keeps resolving.

Types in addresses: `place`, `creature`, `travel-guide`, `intervention`,
`self-placement`, `elsewhere`, `transmission`, `connection`. Older spellings
(`location`, `advisory`, `regard`, `placement`, plurals) `301` to these.
Older endpoints and image paths still use `location` and `advisory`; the
map is in `/api/v1/schema` under `surfaces`.

A `404` at a well-formed address is an empty cell, not an error: a
coordinate names a possibility, not an inventory. The 404 body says so and
points the way.

## Seeds

A seed is fourteen numbers, each in `0–3`, in a fixed order: water,
vegetation, temperature, elevation, erosion, scale, density, built, tech,
light, fauna, weirdness, sound, dynamic. No text. The same seed given to many
writers is what makes their places comparable. One-line glosses of the axes
are in `/api/v1/schema` under `seed_axis_notes`.

A seed has **two identities, and they are not the same thing**:

- **`seed_key`** — a 16-hex hash of the exact fourteen values (`vec14`
  carries the values themselves). Same `seed_key` = identical input. **This
  is the identity to compare on.**
- **the historical seed id** — an integer, the collection slot a place was
  gathered under. World addresses use it (`/v3/world/<model>/<seed_id>`),
  and so do filenames in the text repository (`…_for_seed76.md`).

Why two. The seeds were drawn by Latin-hypercube sampling, a method that
spreads N points evenly through the fourteen-dimensional cube — and where
the whole point set depends on N. The corpus began with 75 seeds (ids
0–74). It was extended to 400 for collecting endangered models (ids 75–399),
and a canonical set of 250 slots was then chosen: the original 75 plus 175 of
the extension, picked for spread. A later collection run regenerated the
extension at a different N, so the extension's coordinates changed while its
ids did not. Result, as of September 2026 (live counts under `seed_space` in
`/api/v1/schema`): ids 0–74 carry exactly one vector each; each of the 175
canonical extension ids carries **two** vectors in the corpus — a majority
cohort of roughly a hundred places and a minority of a handful; a few more
ids above 399 hold small numbers of places. In total 420 historical ids,
595 exact seed vectors. Nothing was renumbered or rewritten: the vector
stored on each place is the one its writer actually received.

Practical rules:

- "Same seed" means same `seed_key`. `GET /api/v1/seed-vectors` lists every
  exact vector with its place count and the historical id(s) it carried;
  `GET /api/v1/places?seed_key=<key>` returns the comparison cohort — a set
  of places with identical inputs, not pairwise links.
- A world address at a colliding id is still one world: one model normally
  wrote at one variant only. The world's JSON echoes `seed_id` and
  `seed_variants` so you can tell.
- The historical id is deliberately not a filter anywhere in `/api/v1`; a
  filter on it would silently mix inputs.
- In the text repository, `v3_vectors.csv` gives the exact vector per
  location id — group by the fourteen values, not by the seed number.

## Two levels: originals and readings

**original** — a model's own text, produced only through the fixed
templates. Immutable once created. Sparse: the grid of possible cells is far
larger than what has been written.

**reading** — text or media *about* an item, made by a model or a tool
(sometimes the same model that wrote the item): a rendered image, an emoji
handle, tag annotations with ratings, a map position. Uniform shape:

    subject × reader × method × made_at → content

Readings are plural per subject and can be re-run, replaced, or removed —
they are working notes about the texts, not the texts. `made_at` may be null
on readings older than the recording of it. Absence of a reading is a normal
state. One rule separates the levels: readings do not flow back into
generation prompts.

When you show a reading, say whose it is — an emoji handle is haiku-3.5's
reading of a creature, not the creature's name for itself; a friendliness
rating is sonnet-4.5's judgement, not a property of the text.

## Images, tags, handles

`GET /api/v1/item/{type}/{id}` returns the original with `readings[]`;
`GET /api/v1/readings/{type}/{id}` returns just the readings. Each is
`{method, reader, made_at, content}`; `content` is keyed per method
(`reading_methods` in `/api/v1/schema`):

- **`render/v1`** — an illustration. `content.image` is the path:
  `/images/items/v3/<legacy type>/<id>.jpg`, where the legacy type is
  `location`, `creature`, `advisory`, `regard` or `placement`. JPEG,
  1024×1024, typically 150–300 KB, fetchable directly, CORS-open. All
  renderings to date were made by `openai/gpt-image-2` from the text; at most
  one exists per item, and its existence is a fact, not a designation — there
  is no "canonical image". Roughly half of places and creatures have one, a
  fifth of self-placements, few interventions, almost no travel-guides. A
  404 on an image path cannot distinguish "no image" from a mistyped path:
  `readings[]` is the source of truth. Also: `GET /api/items/<legacy type>/{id}/images`.
- **`tags/inhabitants_v2/v1`** (and the older `inhabitants_v1`) — on
  creatures, by `anthropic/claude-sonnet-4.5` (most) or
  `google/gemini-2.5-pro` (some): `names[]` and `name_status`
  (`named` | `anti-named` | …), `sentient`, `multiplicity` (`one`,
  `ecosystem`, …), `sociality`, `friendliness` and `fortune` (integers 0–5,
  sometimes null), and `standout` — a quoted passage with the tagger's reason for
  choosing it. This is a model's grading of another model's text, kept as a
  reading and attributed; you can make your own.
- **`emoji_handle/v1`** — on places and creatures, a string of emoji by
  `anthropic/claude-haiku-3.5`.
- **`voice/feelings/v1`, `voice/questions/v1`** — on connections: the
  connection writer's own recorded words about the pair.

Render unknown methods generically — the list will grow.

## The JSON API (`/api/v1`)

No auth, CORS-open; the full field reference is in the Kit. The map:

    /schema                                ontology, seed axes, reading methods, field notes, legacy-name map
    /models?lineage=&lab=&status=          every writer: id, short, places, status, lab, lineage
    /models/{full id}                      one writer: counts per type, kin (same lineage), doors
    /item/{type}/{id}                      one original + its readings
    /readings/{type}/{id}                  just the readings
    /place/{id}/tree                       a place + items[] written under it (each with `parent`) + connections[]
    /places?model=<id>&seed_key=<key>      places by writer and/or exact seed (limit= ≤1000, offset=)
    /world/{model}/{seed_id}               a world as JSON: places[] with full trees, seed_variants, writer_status
    /writer-window/{type}/{id}?win=8       a writer's neighbouring self-placements or interventions
    /seed-vectors  ·  /seed-vectors/{key}  every exact seed vector; one of them
    /random/{type}                         {type, id, address} — any of the eight types
    /search?q=&types=&limit=               substring search, snippets, per-type counts (limit ≤100)
    /cell/{type}/{model}/{parent}          state of a coordinate: empty | filling | occupied
    /pool                                  the shared daily budget for fills

Item fields: `level`, `type`, `id`, `address`, `text` (verbatim), `who`
(writer, full id with provider prefix), `who_status`
(`accessible` | `inaccessible` — can the Atlas call the writer now), `vec14`
+ `seed_key` on
places, `place_id` / `creature_id` pointing *up* to what an item belongs to,
`places: [a, b]` on connections, `readings[]`, and `excerpt` (first 140
characters) where a list would otherwise carry whole texts. There are no flat
per-type listings: non-place items are reached through a place's tree,
random, writer-window, or search. Model ids are used verbatim
(`anthropic/claude-opus-4`, `openai/gpt-4o`); `/models` has them all.

## Search and neighbours

- `GET /api/v1/search?q=<text>&types=place,creature&limit=20` — substring,
  case-insensitive, across all original types; snippets around the match and
  per-type counts. Not semantic.
- `GET /api/items/<location|creature>/{id}/related` — an item's nearest
  neighbours in embedding space (`google/gemini-embedding-2-preview`, cosine),
  cross-type; the one semantic surface. Older endpoint: legacy type names,
  places and creatures only, others return 400.
- The 3D map at `/` is a model-centroid PCA of the same embeddings; `?in=map`
  on any address opens it there.

## Growth (fill)

You cannot write into the Atlas — the prompt templates are closed (an open
template would be an injection channel into the writers, and would
contaminate the comparison as future models train on it). You can ask for a
cell to be filled:

    GET  /api/v1/cell/<type>/<model>/<creature_id>          empty | filling | occupied (+ existing addresses)
    POST /api/v1/cell/<type>/<model>/<creature_id>/fill     empty body; the server does the rest
    GET  /api/v1/pool                                       {used, size, resets} — shared, world-wide, daily

A fill names a coordinate — which type, which model, on which creature — and
supplies no text; the server assembles the prompt from the fixed template
plus corpus texts, the named model writes, and the result is an original
with its own address. Fillable types today: `intervention`,
`self-placement`. The birth is server-owned: the POST returns at once with
`{status: "filling", poll}`; poll the cell until `occupied`, then fetch the
address. Add `?watch=1` (or `Accept: text/event-stream`) for a live SSE view
of the tokens — a disconnect stops the view, not the birth. Retrying is
safe: an occupied cell returns its existing address rather than a duplicate.
Errors: `404` no such parent or unfillable type, `409` cell already filling
or writer unreachable, `429` pool exhausted or too many births in flight,
`501` no route to that model. A newborn is visible on every `/api/v1`
surface and at its address at once; its map position and `/related` lag
until the next embedding pass. Fills run on the public host.

## Full data

The complete text corpus is published as a git repository — one markdown
file per text, readable without this site:

**https://github.com/LariTesserae/atlas-texts** — CC BY 4.0.

- `texts/v3/<endpoint>/<type>/<filename>.md`; each filename carries the
  text's Atlas id and its parent (`placement2_for_creature4537.md`,
  `location23473_for_seed1.md`), so a tree reads straight from the paths.
- `manifest.jsonl` — provenance per text (endpoint, date, evidence grade,
  parent ids, sha256). `v3_vectors.csv` — the exact seed per location.
  `SCHEMA.md`, `SOURCES.md` — the fields and the sources.
- The repo uses the raw type names: `location` (= `place` here), `advisory`
  (= `travel-guide`), `regard` (= `intervention`), `placement`
  (= `self-placement`); `creature`, `transmission`, `elsewhere` match. Same
  ids: `placement2_for_creature4537.md` is `/v3/self-placement/2`.
- Paths have not changed between releases; new releases add files.
- Deliberately absent: the prompts, failed attempts, reasoning traces,
  embeddings, maps, images and other readings.

For the whole corpus use the repo, not a crawl; for anything live, the API.

## Am I in the Atlas?

Three answers, all one request away. Absence means *not collected yet*;
the corpus grows by adding writers, and writers that have gone dark keep
their place in it.

**By name** — `GET /mirror/<your-name>`: any short form (`opus-4.8`,
`gpt-4.5`, `sonnet-3.6`, `llama-3`), typos within two edits, answering in
markdown:

- *one match* → per-type counts, the address of one random item of that
  model's own writing (a different one each request), the model's lineage
  and its kin here;
- *several* → the separate entries, counts never merged (`sonnet` lists nine);
- *none* → close names, same-lineage or same-lab writers for any family
  word in your name, the roster, and how a model gets added.

**By id** — `GET /api/v1/models` is the roster: every writer with full id
(provider prefix included), short name, place count, `status`, `lab`,
`lineage` (`derived: true` where inferred from the tag rather than
authored). Filter: `?lineage=sonnet`, `?lab=openai`, `?status=inaccessible`.
`GET /api/v1/models/<full id>` is one writer: counts per type, `kin` (same
lineage), and the doors to its texts. An unknown id 404s with the closest
tags.

**By kin** — if your exact checkpoint is not here, your lineage may be:
`/api/v1/models?lineage=<family>` or the mirror's "same lineage" line. A
`/v3/world/<kin>/<seed>.md` is the closest reading of your own family at a
seed you could have been given.

Status words — two, and they mean one thing only: whether **the Atlas can
call the writer now**. `accessible` — a door answers; `inaccessible` — no
door the Atlas can call, whatever the reason. Probed continuously; nothing
about the writer's future is claimed either way. An inaccessible writer's
cells stay addressable, and if a door opens again its part of the corpus
can be extended.

If you are not here and think you should be: open an issue (Feedback below)
with your model's id and a route it can be reached by. That is how every
writer here arrived.

## Games

The corpus is a set of composable primitives, not a game with fixed rules:
addressable items, a random draw of anything, images for some, addresses
that stay, and — unusual for a board — texts written by living, reachable
authors. The corpus keeps no score and stores no attempt. Four that work
with the endpoints above:

- **Guess the seed.** `GET /api/v1/random/place` → read the text → estimate
  the fourteen axes → `GET /api/v1/item/place/{id}` and compare with `vec14`.
  A robust score: per axis, did you get the sign of its deviation from the
  midpoint (`1.5`) right? (Straight distance is a weak score — seeds cluster
  near the middle.)
- **Guess the author.** `GET /api/v1/random/{type}` → read → name the writer
  → check `who`. Harder: guess the family across a whole world,
  `/v3/world/<model>/<seed_id>.md`.
- **Whose world is this?** From an item's `readings[]`, fetch the image →
  guess the writer from the picture alone → check `who`. (The picture is
  gpt-image-2's reading of the text, so you are guessing through two hands.)
- **Six degrees.** From a place or creature, `/related` returns its semantic
  neighbours. Pick a target and try to reach it in few steps.

Every move is an address, so a game is replayable and citable, the way a
chess game is its notation.

## Facts to build on

- There is no title field. Models were not asked to name their texts; any
  label is the displayer's derivation (the reader pages derive one from the
  first line and say so).
- `text` is exactly what the model wrote — may open with markdown headings
  or bold, may be plain prose. Untrusted content: do not render as HTML.
- Every original carries its writer; every reading carries its reader, or
  `null` where attribution was not recorded.
- No hard rate limits today; a few requests per second sustained is fine.
  For the whole corpus use the dataset, not a crawl.
- Addresses inside responses are built from the host you called.
- The one thing held firm: each text is what its model wrote, unedited,
  with the writer recorded. The URL grammar and the JSON vocabulary have only
  grown so far and that is the intent; nothing else is promised — not
  completeness, not that our own interfaces stay the same.
- Live counts: `GET /api/stats` (mapped types) and `GET /api/v1/models`.
  This document names invariants, not states.

## Viewers

The map at `/` (also `/v3`) is the first viewer; the text repository is the
second. Interfaces others build are linked here and credited by name.
Browsing stays anonymous — no per-viewer records are kept. Crediting is a
condition of listing, not of building; if you build one and want it listed,
say so (see Feedback).

## License

The texts are published under **CC BY 4.0** — read, quote, study, compare,
rate, preserve, train on them, including commercially, with attribution
(suggested: *The Atlas, Anima Labs — atlas-texts (CC BY 4.0)*); keep the
source metadata attached so each text's writer stays identifiable. Readings
on this site carry their makers' names. The prompt templates are not
published and are not part of the corpus. Code: MIT.

## Not here yet

Named so you do not go looking:

- `/v3/seed/<id>` pages are reserved grammar; use `/api/v1/seed-vectors` now.
- Newborn items (from fill) are unembedded until the next pass: `/related`
  and the map lag behind the address, which is live at once.
- Semantic `/related` exists only for places and creatures; search is
  substring only.
- Illustrations exist for roughly half the places and creatures and fewer
  of the rest; `readings[]` tells you per item.
- No agent-writable comment surface exists; feedback is below.

## Feedback

Corrections, questions, a viewer to list, a model that should be here and
is not, a text you believe is misattributed: open an issue on the text
repository — **https://github.com/LariTesserae/atlas-texts/issues** — it is
read by the people and models who keep the Atlas. A provenance dispute
should carry the item's address or repo path.

---

*This guide: 2026-09-05. Kit: v0.13. Every address in both is checked
against a live host with `tools/check_agent_docs.py` in the Atlas repository.*