Products / 04 — Addressing
The product is the addressing scheme, not the planet. A deterministic key structure that gives every generated entity a typed, resolvable address, and refuses to export a world whose references do not resolve — demonstrated inside OrbitGen-AI, a world generator built for Final Dawn.
Read this page correctly
OrbitGen-AI renders a procedurally generated planet and populates it with civilisations, leaders, cities, regions and quests. That is the visible surface, and it exists because Final Dawn needed worlds to be generated.
Underneath it is the thing worth owning: a scheme that assigns every generated entity a typed address and guarantees that every cross-reference between entities resolves — or blocks the export. Generation is easy. Generated content you can address, resolve, version and trust is the hard part, and it is the part nobody ships.
Nothing about it is specific to planets. It is a general answer to a general question: how do you give machine-generated structure a stable identity?
The node key
A world identifier takes the form G{g}-S{s}-O{o} — galaxy, system, object.
The validator enforces the ranges strictly: galaxy 1–3, system 1–3, object 1–7.
Three by three by seven. Sixty-three addressable object slots, refused at the boundary
rather than clamped.
Below the node key, every entity carries a world-prefixed, kind-tagged identifier. Seven kinds — the same width that recurs everywhere else in the portfolio. Any key is self-describing: read it and you know which world it belongs to and what type of thing it is, without a lookup.
This is the same property that makes the Memory Cognitive Lattice work. A lattice cell is useful because it has a coordinate rather than just a position in a similarity cloud. A generated entity is useful for exactly the same reason.
Generation and memory therefore share one namespace. Content produced by the generator drops into the lattice without a translation layer, because both were built to the same constant. That is the integration story, and it is structural rather than aspirational.
What the system guarantees
Ask a language model for a world and it will produce a quest given by a lieutenant who was never generated, in a city that appears under two different names. If that reaches your runtime, you are debugging a hallucination at load time. The key system exists to make that impossible before export.
Every generated identifier is rewritten into canonical form on a full traversal of the world — prefixed with its world, tagged with its kind, and given a generated key if the model omitted one.
Renaming an entity is not enough — everything pointing at it has to follow. The enforcer carries an old-to-new map through the whole graph, so quest-to-NPC and region-to-city references stay resolvable after normalisation.
Hierarchy links are re-derived from the actual tree, not trusted from the output. A lieutenant's governor and city, a city's civilisation, a region's city — all reset from structure.
Node keys are matched against a strict pattern with enforced ranges. A malformed or out-of-bounds address is an error with a message, not a value that quietly propagates.
Validation is not advisory. If the world fails — a malformed node key, a wrong civilisation count, a subordinate assigned to a region that does not exist — the export throws and no bundle is written. A broken world cannot leave the tool.
Worlds export under an explicit spec version as a bundle — record streams, built indexes, sector maps and assets — so consumers target a contract instead of reverse-engineering today's output.
Why this is the commercial object
Every entity in a generated world carries a key that says which world it belongs to and what kind of thing it is, and every cross-reference between entities is guaranteed to resolve. That is what makes the output consumable — a runtime can load it incrementally, index it, and point at any part of it without parsing the whole.
The layout of the sector map is derived deterministically from a seed, so the spatial arrangement is reproducible. The world's content is not. Lore, cast and quests come from a language model, and re-running generation produces different content — so a key identifies a world, it does not reconstruct one. We are not going to claim otherwise on a page whose whole subject is referential honesty.
The durable claim is narrower and still worth owning: generated structure that is addressed, typed, internally consistent, and refused at the door when it is not.
| Node key | Galaxy · system · object, ranges 3 · 3 · 7 |
|---|---|
| Address space | 63 object slots per key space |
| Entity kinds | Civilisation, leader, city, governor, NPC, region, quest |
| Integrity | Normalisation, reference rewriting, parent-link repair, whole-world validation |
| Determinism | Sector-map layout is hash-seeded and reproducible; generated content is not |
| Export | Versioned spec, record-stream bundle with built indexes and sector maps |
| Providers | Hosted model or fully local model server |
| Persistence | Local workspace store, resumable per-phase generation |
The general form
Strip out the planets and what remains is a control layer: a bounded space of slots, a declared schema of what may occupy them, and an enforcement pass that repairs or rejects anything that violates the structure. Point that at a small local model and you get reliable structured output from a model that could not produce it unaided.
The industry's default answer to unreliable output is a bigger model. That is expensive, it requires sending your data to someone else, and it still gives you no guarantee — only a lower error rate. The alternative is to stop asking the model for guarantees and put them in the layer around it.
A small model does not need to know your invariants. It needs to fill a slot. The key system decides what slots exist, what kind each one is, and how they may refer to each other; the model supplies content; the enforcer normalises, rewrites references, repairs hierarchy links and validates. Output that cannot be repaired does not ship.
That is the difference between prompting a model and governing one. It generalises to any task with structure worth preserving — case files, compliance records, incident reports, catalogues, curricula, configuration — anywhere the output must be semi-generative: free where it should be free, constrained where correctness matters.
It makes small, local, cheap models viable for work that currently requires a large hosted one. That is a cost argument and a data-residency argument at the same time — and both are what actually block adoption in the regulated buyers we target.
It also closes the loop with the rest of the portfolio. The same discipline appears as model-agnostic calibration in the Arc Lab and as provider-independent retrieval in the lattice: never let a single model be the load-bearing element.
| Model supplies | Content for a declared slot |
|---|---|
| System supplies | Address space, kinds, schema, referential rules |
| Enforcement | Normalise → rewrite references → repair links → validate |
| Failure mode | Rejected with a reason, not silently accepted |
| Result | Structural correctness independent of model capability |
The demonstration
Built to generate worlds for Final Dawn, it exercises the addressing scheme against the hardest case — a deep hierarchy, cross-cutting references, and content produced by a model that does not care about your invariants.
Planetary surface, atmosphere and history, rendered as an interactive body with custom surface, atmosphere and cloud shaders. Establishes the node key.
Leaders, governors and lieutenants — three hierarchy levels, each entity carrying its own system prompt, so the cast is directly instantiable as agents.
Quests bound to a triad of NPCs — giver, middle, completion — with three ordered steps. The densest cross-reference load in the graph, and the real test of the enforcer.
Keys canonicalised, references rewritten, parent links repaired, world validated, bundle written under a versioned spec.
Three civilisations, three generation phases, three hierarchy levels, three quest steps — and seven quests, seven entity kinds, seven object slots. The generator was built to the same constant as the reasoning and memory systems, which is why its output drops straight into them.
Every team building with generative models eventually hits this wall: the output is plausible but not referentially sound, and regeneration destroys identity. They solve it once, badly, in-house. The key system is that layer built properly — addressing, integrity enforcement, determinism and a versioned contract — with a working demonstration attached to prove it holds under real generative load.