Ontological foundations of distributed cognitive systems.

The default story about artificial intelligence is the story of a single mind that knows everything. One model. One context. One agent that can be asked anything and will return an answer. It is the cleanest possible mental picture: no coordination, no protocols, no division of labor. It is also, the paper argues, structurally wrong.

Biological cognition is not arranged this way. The brain is not a homogeneous slab of intelligence; it is a federation of specialized subsystems coordinated through well-defined interfaces — executive control in the prefrontal cortex, procedural execution in the basal ganglia, episodic memory in the hippocampus, abstract synthesis in the association cortex. Effective human organizations are not arranged this way either. They distribute cognitive labor across roles: strategists set direction, analysts synthesize, operators execute. Both biology and organizations have, by every available measure, converged on distribution as the structural default.

The monolithic approach fails for predictable reasons. Cognitive overload — a single agent attempting to maintain strategic context, domain expertise, and implementation detail simultaneously exceeds practical context limits and degrades performance across all dimensions. Epistemic confusion — without clear boundaries, agents make claims and decisions outside their domain of competence, producing the characteristic failure mode of confident error. Inflexibility — when capabilities are intertwined, modifying one risks disrupting others. Opacity — when a single agent performs all functions, failures are difficult to localize. Did perception fail, or reasoning, or execution? With a monolith, the question is unanswerable.

The framework's central move is to refuse the monolith and ask a different question: what kinds of agents exist, how do they reason, and what are their boundaries? The answer turns out to be the same answer arrived at by three independent intellectual traditions — a convergence the paper treats not as coincidence but as evidence that something fundamental has been correctly identified.

A common failure in multi-agent systems is undifferentiated authority — the condition in which any agent can, in principle, make any decision. The result is conflicting directives, strategic decisions made tactically, and no clear escalation path when anything breaks. The paper's response is to introduce four semantic logic modes that map the analogy of separated powers onto cognition itself. An agent's mode is not a label for what it does; it is the type of cognition it is licensed to perform.

Bounded epistemology is the principle that an agent should know the limits of its knowledge and operate strictly within its epistemic domain. It is the architectural translation of intellectual humility, and the paper insists it must be enforced rather than encouraged. Humility imposed by guideline is humility that disappears under load. Humility imposed by ontology is humility that the system cannot escape even when something else would be expedient.

The failure modes when boundaries are violated are characteristic and predictable. An OPER-Implementation agent that decides to write architectural guidance leaks implementation detail into principle, polluting the abstraction layer. An ADV-Architecture agent that decides to produce artifacts collapses the distinction between what should be done and what is done, removing the system's ability to verify either against the other. An EXEC-Orchestrator that writes operational state corrupts coordination logic with execution noise. In each case, the failure is not that the agent did something wrong — it is that the agent did something belonging to a different epistemic role.

The organizational parallel is direct. Executives who write code do not, on the whole, run effective companies. Engineers who set product direction tend to produce technically interesting products that no one wants. Architects who execute their own designs forfeit the abstraction that lets them see the system whole. These are not personal failings. They are structural consequences of crossing epistemic lines that a healthy organization keeps drawn.

If the system's specialized agents are its cognitive functions, what mechanism gives the system self-awareness? The paper's answer is to treat metacognition as a first-class architectural concern — a deliberate component, not an emergent property. The Metacognitive Assembler is the name given to this component. It operates one level above the agents themselves, dynamically preparing their context and strategy before they are invoked. It asks, on every invocation: given this task, what does this agent need to know, and how should it approach the problem?

The crucial property is that this metacognition is explicit. It is logged. It is observable. It is debuggable. Where human metacognition is famously opaque — a felt sense of confidence or unease that resists articulation — system metacognition leaves a paper trail. When something fails, the assembler's reasoning can be replayed: which context was retrieved, why, on what evidence of relevance, with what gaps acknowledged. Failure becomes diagnosable in a way that human "gut feeling" can never be diagnosed.

Metacognitive awareness, in the framework, exists at three levels. The agent recognizes its own knowledge gaps and requests guidance. The orchestrator recognizes when the system is stuck — when the same task has iterated three times without progress — and escalates. The Metacognitive Assembler itself recognizes when context is insufficient and logs the insufficiency for later improvement. Each level can fail gracefully because each level can detect its own failure. The system knows when it doesn't know. This is, the paper insists, a far more achievable goal than the system always knowing — and a far more honest one.