Chapter 01
Humans and AI Need a Shared Digital Reality
Humans and AI do not operate over the same explicit digital reality. This is the foundational chapter of an ongoing thesis on how we close that gap.
Fragmented Reality
Humans see tasks, files, devices, projects, rooms, conversations, and workflows. AI usually sees prompts, APIs, tool outputs, and partial schemas.
Both may touch the same systems, but they do not share the same explicit truth.
A human may understand that “the front door is locked” or “this repository is broken,” while an AI often sees only fragmented API responses, prompt context, or tool output. They are acting around the same reality, but not over the same explicit model of it.
Reality Has Structure
Reality does not wait for software to describe it. Rooms, devices, files, conversations, workflows, and changing state already carry structure and meaning.
Humans operate over that territory directly. They know what a locked door means, which screen is active, or when a repository is broken because the world they are acting in is already organized.
Software is not inventing that structure from nothing. It is trying to model it.
Text Hides the World Model
Current software already models reality. Whenever software represents homes, doors, televisions, channels, files, tasks, or conversations, it is carrying a world model.
The problem is not that software lacks structure. The problem is that most systems keep that structure trapped inside source code and exchanged as text.
Interfaces expose fragments. APIs expose fragments. Tool outputs expose fragments. Humans and AI meet the system mostly at those boundaries, while the model itself remains hidden.
The Graph Makes the Model Explicit
If the world model is the real thing we care about, it should not remain implicit inside code. It should become explicit, shared, and canonical. By canonical, I mean one structural representation of the world model that interfaces, services, and actors can interpret consistently.
This is the role of the Object Config Graph.
The Object Config Graph is a declarative graph that describes:
- the objects that can exist,
- the state they can hold,
- the relationships between them,
- and the valid operations over them.
This is the map.
This is also the move Aware is implementing at aware.run: make the model itself explicit so interfaces, services, and actors can operate over the same structural truth.
Map, Projection, Territory
The Home example makes the sequence concrete.
The Object Config Graph (OCG) is the map. It defines what can exist in this reality: Environment, Home, Door, Tv, TvChannel, their relationships, and the valid operations over them.
The Object Projection Graph (OPG) is the projection over that map. In
the Home diagram, the blue Home projection is that semantic scope. It does
not create a second world. It selects the part of the map that matters for a
specific representation, workflow, or experience.
You can think of projection as the lens over the map, but the important point is that it remains structurally grounded in the same shared configuration.
The Object Instance Graph (OIG) is the territory of that projected scope once it is instantiated as actual objects and state: a specific home, a specific door, a specific television, a specific active channel.
This gives us a clean sequence:
A projection is therefore more than a filter. It selects a meaningful scope of the map and gives that scope semantic purpose. Interfaces then materialize that scoped projection as panes, making state changes visible as observable deltas.
A conversation, for example, may project messages, text, mentions, and participants. A home may project doors, screens, and active channels. A repository may project code structure, layout, and text artifacts.
The key idea is that the map remains shared, while different projections allow humans and AI to work over meaningful scopes of that same world.
Evolving the Territory Through Commits
Once a shared territory exists, the next question is how it evolves.
Git offers a useful reference point. A repository is a projection over a software world: a meaningful scope in which files, directories, and text become the territory of interest.
That territory evolves through deltas bundled as commits, and a specific commit acts as the head from which state can be reconstructed.
Aware takes this same core principle — attributable change bundled as commits — and applies it beyond text repositories to general-purpose projections over a shared world model.
This is the boundary where canonical representation becomes canonical evolution.