The system as one object
does not exist anywhere.
So we built it. Not a diagram somebody updates. Not a catalog somebody forgets. The model itself, live, verified, with stable coordinates and confidence on every edge. The map, not the territory.
Observability is the territory. blastmap is the map.
Maximum resolution. Unnavigable.
Logs, traces, metrics, span trees. Petabytes of ground truth. Every byte real, none of it composed. You can drown in the territory and still not be able to answer "what does this service depend on" without a human reconstructing it from fragments.
Deliberate abstraction. Stable coordinates.
Nodes that mean something. Edges that mean something. Identity that survives renames. Confidence on every claim, provenance on every edge. A level of zoom you can choose. The map is the level of detail at which the system becomes legible.
What we believe about modeling a software system.
Most cross-service edges are invisible to formal schemas. Wrapped clients, dynamic dispatch, queue topics, env-coupled databases. If your model only sees the schema, your model is wrong.
Confidence is a first-class property of every fact about a system. A model that has no number on its edges is lying.
Provenance is the only honest answer to 'how do you know'. Every claim cites the extractor and the location it came from.
Freshness is the only honest answer to 'is this still true'. Every fact knows when it was last verified.
The declared system and the observed system are not the same system. The model must hold both and report the delta.
Unknown is not safe. A missing edge is not the absence of a relationship. The model must render unknown as unknown, never as zero.
Identity survives. A service does not lose its history because somebody renamed the repo. The model holds the lineage.
One artifact serves the human and the agent. The same nodes, the same edges, the same confidence. The model that an architect reads is the model an agent reasons over.
Agents that act on the system need the model. Agents that act without the model are confidently wrong, which is worse than nothing.
The model is the moat. Anyone can build an agent. Almost nobody is willing to build the substrate first.
The human problem and the AI problem are one problem.
Ask a senior engineer "what breaks if I touch this" and they reconstruct the answer from memory, lore, recent PRs, and a few tools. Ask an agent the same question and it reconstructs the answer from grep, docs, and a few tools. Both rebuilds are slow. Both are lossy. Both fail at the seams the formal schema does not see.
We refuse to solve the same problem twice. One model. One set of coordinates. One discipline of confidence and provenance. The human reads it. The agent reads it. The answer they get is the same answer.
The world model is the work.
Everything good downstream falls out of it.
We are not building another catalog. We are not building another AI-SRE. We are building the substrate that makes both honest, that makes agents trustworthy, that makes the system finally legible to the people and the machines that have to operate it.