A system that maps the WHY of its own code, and watches itself act.
The graph maps every code unit, decision, doctrine, contract, and runtime to the reason it exists, and injects that map into the agent every turn. Sentinel flags crashes and errors as they surface. Together they bound the reasoning with evidence, the way the operating loop bounds execution with receipts.
This is not a separate user product. It is wired into the per-turn packet that drives the agent that builds and operates Aria. The cockpit that briefly appeared on this page belonged to a different product and has been removed.
Code reasoning and self-watching are scattered. The agent assumes. The runtime drifts. Decisions land without a traceable cause.
An agent that reads code without a map of why the code exists reasons from habit, from training, or from the last file it touched. Errors are observed after they ship. Decisions are made without a record of which doctrine or contract they satisfy.
A graph that resolves every code unit, decision, doctrine, contract, and runtime to the reason it exists, injected into the agent before it acts. A Sentinel loop that flags high-severity runtime failures as they surface. Real proof sits in the proof room under NDA.
The frame below is the live self-intelligence surface. It is filled from the system itself, not from a static document. Atlas reads the codebase, builds the map, and ships the slice the agent needs. Sentinel reads the runtime and reports the count.
The map is not a flat index. It is a typed graph. Each kind of node is counted and resolvable to a source.
Nodes alone are a taxonomy. The graph is the edges. Every relation has a type, a count, and a note about what it carries.
Atlas is injected at the pre-cognition stage of the per-turn packet, before the agent selects a tool or emits a thought. Sentinel flags at the post-tool stage, after the runtime reports back. The two loops run async and in parallel, so self-map and self-watch do not block each other. The per-turn stages are pre-cognition, pre-tool, intra-cognition, intra-tool, post-cognition, and post-tool.
Pre-cognition. The graph slice for the active context is loaded into the agent before it reasons.
Intra-cognition and intra-tool. The agent reasons from the cited edges and acts on the cited units.
Post-tool. Runtime errors and crashes are reported back, severity is counted, and the per-turn high count is exposed in the proof room.
The per-turn Sentinel high count is exposed in the proof room and updated each turn. Currently zero unresolved.
The graph is not frozen. It is built from 9 substrates: behavioral, cognitive, conversational, doctrinal, historical, hive-state, repo-state, runtime, and structural. Each substrate contributes a layer of nodes and edges. The combined state is captured in 46 snapshots, so a change to the code is diffable against the substrate it came from. A refactor traces to its cause before it lands, not after.
The system is real. The proof is real. The limits are also real, and they are named here on purpose.
The boundary between a system that remembers code and a system that knows its code is the boundary Atlas closes. The next mile of proof is more demanding than the last.
The agent that builds and acts on Aria's own code reasons from the cited WHY of every unit, every turn, with a watch on what breaks. That is the governance layer frontier labs still treat as research.
Per-turn Sentinel counts tied to specific incidents, and a diff of the graph across a substantive refactor showing the substrate actually caught the blast radius. Both are queued for the next review window.