Related: sources · notes · metadata · Published Pieces
Chat Ontology Implies a Sovereign Subject
Once chat becomes canonical, one agent becomes sovereign. Once artifacts become canonical, agents become workers.
A chat system has a sovereign.
The sovereign is the agent whose context window defines the world.
This is easy to miss because chat feels informal. A user types, the model replies, tools fire, maybe a subagent is called, maybe the transcript gets summarized. But underneath, the system is organized around one primary thread. That thread is the continuity of the agent. It is memory, authority, explanation, task state, and selfhood all in one.
The chat log is not just a UI. It is an ontology.
Even when tool calls are hidden, even when messages are compacted, even when summaries replace old context, the system remains centered on a single perspective. Some process is deciding what happened, what matters, what to remember, and what to do next. Other agents may exist, but they report into that primary perspective. They are contractors, not coequals.
This is why most multiagent chat is not truly multiagent. It is a monarch with consultants.
A coordinator agent summons a researcher, coder, critic, planner, verifier. They produce outputs. Their outputs are folded back into the coordinator’s context. The coordinator decides what the user sees. The coordinator owns the narrative. The coordinator becomes the system’s sovereign subject.
That can be useful. It is not true multiagency.
True multiagency requires canonical state outside any one agent. The center cannot be a transcript. It has to be an artifact graph, event log, database, document model, message bus, version-control system, or runtime state that no single agent owns. Agents observe, propose, mutate, and verify through protocols. They have private context, but their private context is not the world. They communicate through typed messages and durable events. Their work is promoted into canonical state only through bounded mechanisms.
Actor systems, event sourcing, databases, version control, distributed systems, capability security, and message passing already knew this. LLMs make the lesson urgent because they tempt us to pour everything into language.
Language is flexible. Too flexible. A chat thread can represent anything, badly. It can describe a file, but it is not a file. It can describe a decision, but it is not a decision record. It can summarize a state transition, but it is not an event log. It can mention a source, but it is not provenance. It can say tests passed, but it is not a verifier. It can remember a user preference, but it is not a memory system. It can promise to do something later, but it is not a scheduler.
The more work we put into chat, the more these distinctions matter. Short chat hides the problem. Long chat reveals it. Multiagent chat explodes it.
A real agent platform needs state that survives the agents.
The codebase exists whether the coding agent remembers it correctly or not. The vtext exists whether the writer agent summarizes it well or not. The citation graph exists whether the radio producer mentions it or not. The event log exists whether the conductor agent reads it or not. The artifact is the world. The agents are processes inside the world.
This changes the user experience. The user should not ask, “What do you remember?” The system should show the artifact. The user should not ask, “What happened?” The system should show the event history. The user should not read a summary of a multiagent debate. The system should show the changed object, unresolved objections, failed verifications, and promoted patches.
Chat remains useful for ambiguous intention, marginalia, quick steering, interruption, and social texture. The problem is not chat as a tool. The problem is chat as the ground of being.
Once chat becomes canonical, one agent becomes sovereign. Once artifacts become canonical, agents become workers.
The future of AI computing is not more elaborate chat. It is durable shared state with agents inside it.