A Parallel-Drafts Architecture for Modelling the Self

TheThe theory series on this site's topics track built an argument across four pages for treating a system's own body and capabilities as one more object inside its own cognitive machinery. This page states where that argument lands when it becomes an actual implementation: a real, working PatLang project called self-model, built component by component against a requirements specification and a companion safety document. The weak-claim framing from that series holds throughout — this is an analogue, not an instance¹.

This is the same diagram this site's Sense, Model, Think, Predict, Imagine, Act page sets out in the abstract, built for real — the node names below are the actual PatLang components, and the dotted/solid distinction from that page carries over unchanged (dotted = slow background compilation, not a live per-turn data flow):

Two differences from the abstract diagram are worth naming. First, every edge above is a named topic on PatLang's own message queue, not a metaphor — representation_updates and perception_schema_feedback are real queue topics read and written by the real components documented on the pages linked below. Second, Self-Model sits as one more node rather than a special case: its opaque-mode output feeds Representation exactly the way Abstraction's does, and its transparent-mode output feeds Perception's schema-expectation channel exactly the way Abstraction's does — Requirement 4.2/4.3's opaque/transparent split, described in the section on instrumentation and transparency below, is the choice of which of two already-existing edges a prediction travels down, not a third mechanism invented specifically for self-modelling.

Global Workspace as competing drafts, not verified consensus

Dennett'sDennett's Multiple Drafts model proposes that cognition runs as many parallel, distributed, content-specific processes, with no central process whose output counts as the official one. What gets reported or acted on is whichever draft is being probed at a given moment, continuously revised rather than retrieved from a privileged internal stage². That is a different claim from a verification scheme that checks whether several independent computations of the same thing agree with each other. A verification scheme assumes there is a single correct answer underneath the redundancy. Multiple Drafts assumes there may be no single correct draft to converge on at all — disagreement between drafts is expected and informative, not an error condition to be resolved away.

Baars' Global Workspace Theory gives that idea a mechanism: many specialised processors read from and write to a shared, limited-capacity broadcast space³. The implementation runs Perception and Reason/Plan as genuinely parallel, independently-computed instances — multiple Perception evaluators reading the same raw text, multiple Reason/Plan candidates evaluating the same situation — competing for uptake on a shared queue and also feeding off each other's postings. That is Multiple Drafts stated as an architecture rather than kept as a metaphor for one.

PatLang as implementation substrate

ThreeThree pieces of PatLang's existing infrastructure map onto this architecture without modification, which is itself informative — the pieces were built for other reasons and turned out to already fit.

The message queue module already provides durable, disk-backed publish/consume/acknowledge coordination. Used as the shared workspace above, multiple competing drafts publish to it, and the system's next action is whichever draft's content wins uptake — exactly what the theory requires, with no bespoke coordination mechanism needed.

The inductive synthesis engine — the same system elsewhere on this site's PatLang material described as reading Given/When/Then examples and deriving working code that satisfies them — covers two of the architecture's edges with one mechanism. Short Term feeding Abstraction, and Short Term feeding Procedural Memory, are both structurally the same operation: induce a general rule from accumulated specific examples. The engine's actual function is aimed first at category induction (Abstraction) and second at compiled action rules (Procedural Memory), but the underlying mechanism doesn't change between the two.

Design by Contract gives the self-model something external to be checked against. A forward-model prediction — if the system does X, Y follows — stated as a contract precondition/postcondition pair and checked against what actually happened afterward gives real, external verification of the opaque self-model specifically, because its predictions are explicit and available to be tested against subsequent state, rather than trusted on the strength of how the prediction was generated.

Where perception and conversation meet connectionist reasoning

ForFor a developmental version of this architecture, the obvious environment is text: web content and conversation with users, not a physical sensorimotor world. That environment suggests a specific division of labour rather than a uniform architecture throughout. Ollama-backed language models handle Perception (parsing unstructured text into candidate objects and intents) and Action (generating conversational output) — the two boundaries where matching the statistical patterns of real human language is exactly what connectionist processing is suited for. Everything between those two boundaries — Abstraction, Episodic Memory, the self-model, Reason/Plan — stays PatLang's own symbolic machinery. This follows the same discipline established elsewhere on this site for language-model output generally: nothing from either boundary is trusted directly. Everything is checked by the symbolic core the way any other unverified input would be⁴.

The concrete risk of learning from open conversation, and its concrete answer

Microsoft'sMicrosoft's Tay is a documented case of exactly the failure mode this combination invites. Launched in 2016 with a mechanism that repeated back language it was fed, Tay was flooded within about an hour by coordinated users feeding it racist and inflammatory content, and was shut down roughly sixteen hours after launch, having produced tens of thousands of posts including material Microsoft itself later apologised for⁵. The failure was not a technical malfunction in any narrow sense. It was a compilation mechanism — repeated exposure updating a rule base — with no distinction built in between legitimate and adversarial repetition.

Abstraction's classification and Procedural Memory's compilation both update from exactly this kind of repeated exposure. The answer implemented here is not to remove the mechanism but to gate it: compilation weighted by the interlocutor's trust score, computed via this site's own distributed embedding calculus of trust, rather than accepting all repeated input as equally worth compiling into the rule base. A bootstrapping phase of curated, vetted interaction, run before any exposure to open input, gives the system an established baseline to weigh a coordinated bad-faith flood against, rather than nothing to weigh it against. That makes a good-faith deployment of this architecture robust to the Tay failure mode specifically. It does not make the underlying approach immune to a bad-faith implementation built on the same design with the safeguards stripped out — that is a limit of what any one implementation can guarantee, not a gap in this description of it.

Instrumentation and transparency are separate axes

Transparency,Transparency, in Metzinger's sense, concerns whether the system's own downstream reasoning can access a component's output as a labelled, inspectable model-state⁶. Instrumenting every component with PatLang's signals API — including the self-model — concerns something different: whether an external, out-of-band process can query a component's state for audit purposes. These two properties are independent of each other. A self-model can route its output only through the transparent path into Perception, invisible to the system's own Reason/Plan, while simultaneously exposing full state to an external auditor who never feeds that signal back into the cognitive loop. That gives real engineering verification: whether the component is functioning correctly, whether its behaviour has drifted, whether it shows early signs of the kind of corruption Tay suffered. It does not give access to whether anything is being experienced while the component computes. That question is untouched by instrumentation quality, for the same reason argued at length on the second page of the theory series this implementation is built from.

An inner narrative, and what it would actually be

SignalsSignals carrying instrumentation data can be consumed by the same Ollama-backed language model handling conversation, generating a fluent narrative account of the system's own recent internal activity. This is not speculative window-dressing bolted on for effect — it is what the evaluation work described on the companion evaluation page actually runs. Dennett's account of the self as a centre of narrative gravity holds that a self is not a located inner viewer but an ongoing, continuously-revised story a system tells about itself: real and useful as an organising abstraction, without being a discoverable thing sitting anywhere inside the system⁷. A language model narrating from genuine instrumentation data, rather than from an invented account, is a direct engineering instance of exactly that description, not an illustration borrowed to explain it after the fact.

This is also the point at which the architecture stops being something to guard against overclaiming and becomes something to measure instead. A system that produces a fluent, internally-consistent narrative of its own states is either evidence that the functional and reporting profile associated with experience is fully present with nothing further needed to explain it, or evidence that something further is still missing despite every measurable signature being there. The illusionism and phenomenal-realism positions discussed on the theory series' second page read the same result differently, but both positions need the result to exist before they can argue about what it means. What that creates as a requirement is an evaluation protocol: a stated method for measuring how convincing the produced narrative is against a baseline, so the outcome is recognised and reported in whichever direction it actually goes, rather than assumed in advance. That protocol is the subject of the companion evaluation page.

Imagination inherits the same schema, and predicts its own decline

TheThe theory series established that Abstraction feeds back into Perception as schema-driven expectation. The same connection into Imagination predicts a specific, testable effect. Luchins' classic experiments found that after solving several problems with the same method, people kept applying that method to new problems even when a simpler solution existed, with the effect most pronounced in domains of accumulated expertise⁸. A system whose Imagination is filtered through an increasingly rich Abstraction layer should show the same pattern: measurably declining novelty in imagined scenarios as accumulated experience grows. That gives the evaluation protocol a second, independently-motivated measure, alongside narrative convincingness — not proof of anything about consciousness, but a second signature worth checking for rather than assuming away.

See also

ThisThis page states the architecture; Safety and Ethics Requirements for a Self-Model states the constraints that govern building it, and Evaluation: Narrative Convincingness and Imagination Novelty covers the two measures introduced above in full. For the component-level implementation, see the orchestration page and the individual component pages (Self-Model, Imagination, Reason/Plan). This architecture is built to satisfy the theory argued across four pages on this site's topics track: Modelling the Self: Object-Oriented Cognition Applied Reflexively, Does a Self-Model Get You Anywhere Near an Analogue of Consciousness?, The Ethics of Building Something That Might Model Itself Into Suffering, and What This Series Isn't Claiming.

References