From Modeling Consciousness to Building It?

A research note on physical computation, progressive fidelity, and artificial consciousness

Dar Aystron

Independent Researcher

I am seeing growing interest in artificial consciousness. One way researchers are approaching the problem is by looking at the AI systems we already have, particularly large language models, and asking whether they might already possess some elements of consciousness, whether consciousness could emerge as these systems become more capable, and what evidence we would even accept if it did.

With OODA Agency Theory (OAT), I have been approaching the problem from another direction. Instead of starting with an existing model and asking whether consciousness might somehow be present inside it, what happens if we deliberately build artificial systems around properties that appear to matter for consciousness? We can construct mechanisms for persistent identity, continuity of experience, perception, attention, mental states, a subject stream, needs, attachments, self-models and artificial phenomenology. We can put those mechanisms inside an agent that continuously observes an environment, orients, decides, acts, experiences the consequences of those actions, and changes over time.

Working hypothesis: We can model consciousness to progressively higher levels of fidelity.

By progressive fidelity, I do not mean simply taking one mechanism and making it more sophisticated. Much of the progression comes from adding properties that were not represented explicitly in earlier generations of the architecture, and then integrating those properties with everything that is already there.

My early agent prototypes, for example, could observe, orient, decide and act, but they did not have an explicit agent-level attention mechanism - that is, a mechanism for deciding what the agent itself should focus on, rather than the internal attention mechanism of an LLM. I am now working on adding attention explicitly. That immediately creates a richer architecture. How does attention interact with perception of the external world and with interoception - perception of the agent’s own internal state? What becomes salient? What enters the subject stream? What gets remembered? How do needs and attachments influence attention? How does previous experience change what the agent notices next? Because attention is something the agent can direct, OAT models shifts of attention explicitly as internal actions rather than treating attention as simply a passive filter.

The same progression has happened, and can continue to happen, across identity, memory, needs, attachments, self-models, phenomenology and other properties associated with consciousness. A new mechanism does not simply add another item to a checklist. It changes relationships throughout the architecture. Adding attention changes perception, memory and orientation. Adding attachments changes what becomes salient and how possible actions are evaluated. Adding a subject stream changes how experiences are organized through time. The architecture becomes richer because these mechanisms increasingly affect one another.

This is what I mean by progressive fidelity. We identify another property that appears relevant, work out what it would mean functionally inside an agent, implement it, integrate it with the rest of the architecture, and then observe what the resulting agent becomes.

I approach this primarily as a builder. For roughly the last ten years I have built several generations of artificial agents, and this pattern has repeated itself. Each generation has made more of what was previously implicit explicit, added mechanisms that were previously absent, and connected them into an increasingly integrated agent architecture. That experience has given me increasing confidence in the hypothesis. Not confidence that these agents are conscious, and not confidence that consciousness can simply be reduced to a list of functions, but confidence that we can construct systems that capture progressively more of the organization associated with consciousness.

Eventually this leads to a question I find particularly interesting: At what point are we no longer just modeling consciousness?

The usual analogy here is weather. A computer can simulate a hurricane with extraordinary accuracy, but nobody expects the computer to become windy or wet. Therefore, the argument goes, a computer simulation of consciousness would still only be a simulation.

I am not sure the analogy survives once we start talking about agents.

A weather model represents another system. The atmospheric pressure stored in a computer is a representation of pressure somewhere else. It does not itself push air across Miami. But imagine an attention mechanism inside an artificial agent. If that mechanism actually determines which external perceptions or internal states become salient, what enters the subject stream, what gets remembered and ultimately what the agent does next, in what sense is it merely simulating attention? Within that agent, it is doing the work of attention.

Memory creates the same problem. An artificial agent encounters an event and its persistent state changes. Later, that state changes how it interprets another situation, which changes its orientation and decision, which changes what it does, which changes the environment it subsequently encounters. That memory is not describing a hypothetical memory belonging to another entity. It is part of the causal history of this particular agent.

Needs and attachments can work the same way. If the state of a need changes the agent’s orientation toward possible actions, it is causally participating in the agent’s behavior. If repeated interaction with another entity changes an attachment, and that attachment subsequently changes what the agent notices, how it interprets a situation and what it chooses to do, then the attachment is not merely a representation of an imaginary relationship. It is doing work inside the agent.

This does not show that such an agent is conscious, and it does not settle the question of subjective experience. It makes a narrower point. The hurricane analogy assumes a separation between the model and the system being modeled. But when attention, memory, needs and other mechanisms are implemented as parts of the agent’s own causal architecture, they are not merely representations of those functions somewhere else. They are actually doing that work within the agent. Whatever may still be missing for consciousness, the situation is therefore importantly different from simulating a hurricane.

This becomes especially important in OAT because the agent is continuously coupled to an environment. It observes, orients, decides and acts. Its action changes the environment. The changed environment produces new observations. Those observations change the agent again. External perception is joined by interoception: the agent can also observe aspects of its own internal condition. Attention can move across both. Over time, a history develops that belongs to that agent and no other one, and the mechanisms we have implemented participate in producing that history rather than merely describing it.

That is already quite different from tomorrow’s weather forecast.

There is another assumption hidden underneath this discussion that I think deserves more attention. We often talk about computation as if it were abstract. The Turing machine encourages us to think this way, and for computer science it is enormously useful. We can describe an algorithm independently of the machine executing it, reason about computation symbolically, and move software between different physical systems while preserving its logical behavior.

But an actual artificial agent running on a computer is not an abstract Turing machine.

Computation is physical.

Every bit has a physical state. Every state transition is a physical event. Memory requires a physical implementation. Communication requires signals moving through something. Computation takes time and consumes energy. Sensors connect the agent to its environment and actuators allow it to change that environment. Those interfaces may be physical devices, but they can just as easily be software interfaces such as chat, APIs or other digital channels. A chat message received by an agent is a real event in its environment, just as the message it sends back is a real action that changes that environment. Underneath all of this, the running interaction is still physically instantiated computation. OAT Paper 04 [5] develops this idea in more detail by treating action realization as a physical process through which an agent changes its environment.

Today I can implement an OAT agent using conventional computers. That is a perfectly reasonable place to start, but a conventional von Neumann architecture was not designed as a particularly clean physical realization of an architecture for consciousness. A processor executes instructions, repeatedly moving data between computation and memory, while giving us an abstraction on top of which we can implement almost anything.

On a conventional machine, activity associated with different functions is heavily multiplexed through shared processors and memory. In a distributed architecture, we can instead give different physical components affinity to different agent functions, making timing, communication and energy flow part of the architecture we can observe and manipulate.

Now imagine something deliberately less convenient. Imagine a thousand Raspberry Pis connected together with functional affinity.

I am not suggesting Raspberry Pis are consciousness hardware. The purpose of the thought experiment is to make the physical organization visible. Instead of treating the thousand machines as interchangeable compute capacity, we organize them around the functional architecture of the agent. Groups of nodes have affinity to perception, interoception, attention, memory, needs, attachments, orientation, action selection and other processes. Within those groups there can be further specialization, while communication patterns among the groups reflect how the functions interact.

Now the logical architecture begins to have a corresponding physical architecture. Perception is happening somewhere. Memory is maintained somewhere. Attention involves physical activity across particular components. A change in a need can propagate through one part of the system, influence attention somewhere else, alter orientation, activate memories and eventually affect an action.

Some mechanisms operate continuously while others become active only under particular conditions. Information moves over physical links. Delays appear. Failures happen. Some processes compete for resources. Others synchronize. The architecture has topology, and that topology has functional meaning.

There is no single processor repeatedly stepping through a function called consciousness(). There is a distributed physical system whose components continuously interact while the overall system maintains an ongoing relationship with its environment.

Now I want to look at something we normally ignore when we draw software architecture diagrams: energy flow.

With functional affinity, energy flow becomes especially interesting. We can observe not simply how much energy the system consumes, but where physical activity is occurring and how it moves through the architecture. What changes when attention moves from an external object to an internal state? What happens physically when a need becomes urgent? Does activity propagate differently when something associated with a strong attachment appears? What happens across perception, memory, attachment and orientation when a chat message arrives from someone the agent knows well, compared with a message from someone it has never encountered before? Which mechanisms remain active while the system is apparently doing nothing? What physical activity is necessary simply to maintain continuity?

Now imagine that each of those thousand computers also has a set of colored lights whose brightness and color are causally tied to its internal state and current processing. The lights are only a way of making the physical activity visible. A light comes on when the chat sensor receives a message from a user. Activity begins moving through perception, attention, memory, needs and orientation. Different regions brighten, fade or become active together. Eventually the agent decides to respond and another light comes on when the chat actuator sends the message.

Stand back and watch this system for a while. What would we see? Perhaps recurring patterns of activity as the agent analyzes a chat message, identifies intent, retrieves relevant memories, shifts attention, responds to changing needs and acts. Some regions might remain quietly active while others flare briefly. Different situations might produce recognizably different patterns across the architecture.

This would not tell us whether the agent is conscious. But it would make the physical dynamics of the agent visible: perception, memory, attention, needs, attachments, orientation and action causally interacting in real time.

Once we stop treating computation purely as an abstraction, an artificial agent becomes a physical dynamical system. Its functional organization is physically instantiated. It changes internal physical states, consumes energy, exchanges signals with its environment, maintains its organization over time, and produces actions that alter what happens to it next.

The physical organization also affects something less visible but potentially just as important: timing. Imagine that semantic memory is distributed across fifty of those machines. When the agent learns something, that memory is physically stored somewhere across those fifty machines and later has to be retrieved through the network. Suppose the agent is interpreting a new situation and needs a relevant memory from a previous interaction in order to orient correctly. In one physical configuration, that memory becomes available in about 10 milliseconds. Move the same software, memories and logical architecture onto a different physical configuration and retrieval now takes 50 milliseconds. The information has not changed, but the causal timing of the agent has.

In OAT agents, that can matter. The agent’s causal models do not capture only which events, states and actions depend on one another; they can also include expectations about timing. In a dynamic environment, those temporal relationships may be critical. Information that normally becomes available within 10 milliseconds may participate in orientation and action in a very different way if it now takes 50 milliseconds to arrive. Change the physical topology, latency or locality and some of the causal regularities the agent has learned may no longer hold. The agent may need to adapt not because the external world changed, but because the physical system through which it engages that world changed.

That suggests something interesting: an agent may learn not only a causal model of its environment, but also regularities about its own cognition. If those regularities are partly shaped by physical implementation, moving the same agent to different hardware may preserve its memories and software while changing how it actually functions. The physical realization may become part of the agent’s history and learned causal structure.

At that point, fidelity is not just about making the agent behave more like a human. It is also about how the mechanisms are organized and connected, how they influence one another over time, and how the agent develops through continuing interaction with its environment. As we add attention, memory, needs, attachments, self-models and other capabilities, the important question is not only whether each mechanism works, but what kind of integrated system they create together.

OAT Paper 12 [4] explores part of this from another direction. Once an agent develops through its own experiences, attachments, actions and consequences, its history becomes increasingly singular. At some point we are no longer dealing with an interchangeable software instance whose state can be understood only from its source code. We are dealing with a system that has become what it is partly because of what has happened to it.

Philosopher David Chalmers approaches a related question from the other direction. Across his work on LLM consciousness and on “threads” [2,3], he asks what the continuing entity actually is when we interact with an AI system over time. His answer is not simply the model or the hardware instance, but the continuity of computational state, memory and psychological structure across successive interactions.

I find that especially interesting because it is close to the identity side of the same problem. Chalmers asks what we are talking to, given how today’s systems are built. OAT asks what we would need to build so that identity, continuity and agency exist by design. One approach is descriptive, the other constructive, but they increasingly meet around the same questions of persistence, memory, identity and eventually consciousness.

Now imagine continuing this process of progressive fidelity. Someone identifies another functional property they believe is important to consciousness. We try to understand what that property actually does and how it relates to the rest of the system. Perhaps it requires an entirely new mechanism. Perhaps it changes several mechanisms we already have. Perhaps implementing it forces us to rethink part of the architecture. We build it, integrate it, observe what changes, and continue.

Over successive generations, the agent gains richer identity and continuity. Attention becomes explicitly connected to perception and interoception. Memories alter future perception and orientation. Needs affect what becomes salient. Attachments affect what matters. A subject stream connects experiences through time. The system’s physical state continuously changes through interaction with its environment, while its individual history increasingly becomes part of what the system presently is.

Fidelity here is not a single score. It increases as we identify independently motivated properties associated with consciousness, implement them as causal mechanisms, integrate them with the existing architecture, and test what difference they make to the functioning and development of the agent.

Someone can still say:

It is not conscious. It is only modeling consciousness.

Perhaps they are right. But at that point I want to ask a more precise question:

What exactly is missing?

“What exactly is missing?” is not intended to shift the burden of proving consciousness. It is a methodological question. If some property is necessary for consciousness and absent from the architecture, I want to understand that property well enough to investigate it. Simply naming subjective experience does not yet tell us what would have to be different about the system. If biological substrate, some particular causal organization, or another physical property is essential, then that becomes another hypothesis we can examine.

Chalmers’ philosophical-zombie thought experiment [7] makes this challenge particularly sharp. Imagine a system that is physically and behaviorally indistinguishable from a conscious person, but has no subjective experience at all. OAT does not resolve that problem. The progressive-fidelity hypothesis approaches it from the constructive side: if we continue implementing more of the functional, causal and architectural organization associated with consciousness, what exactly would still distinguish the resulting system from a conscious one?

My answer is not simply that we could build Star Trek’s Data without human feelings. I am not advocating that artificial agents should simulate human feelings. But I do think that something playing a similar architectural role is important in a conscious system. OAT therefore explores computational correlates of needs and feelings through artificial phenomenology [6]: internal experiential states that matter to the agent and help shape how it evaluates its situation and what it does next. Whether such structures are accompanied by subjective feeling in the human phenomenal sense remains an open question. But progressively more of the role that feelings play within a conscious architecture may itself be something we can construct.

If consciousness requires biological neurons, that is an interesting hypothesis. Mustafa Suleyman has argued that consciousness is very likely biological and may depend on the substrate of living systems [1].

Perhaps some particular electrochemical, electromagnetic, analog or other physical process is essential. Those possibilities are interesting precisely because they give us another property to investigate.

Once that property is described clearly enough, we can ask the same question again: can it be represented or implemented in an artificial physical system, and what would higher fidelity look like? Perhaps the answer will eventually be no. Perhaps we will find something that cannot be reproduced outside a particular biological substrate. Or perhaps implementing one property will simply expose another property that matters.

A running artificial agent is a physical system. Computation is not something outside the physical world; it is implemented through physical states, transitions, communication and energy use. The deeper question is therefore not whether an artificial agent is “just computation”, but what physical and functional organization consciousness requires, and how closely we can construct that organization artificially.

So I return to the working hypothesis: We can model consciousness to progressively higher levels of fidelity.

This is the direction of the OAT research program today. We are progressively incorporating richer functionality and modeling more of the properties associated with consciousness, while in parallel building prototypes to clarify, test and evolve the system architecture. Theory suggests mechanisms; implementation exposes assumptions and missing pieces; what we learn from the prototypes then feeds back into the theory.

The technology available for these experiments is also changing quickly. New generations of LLMs already give agents increasingly powerful capabilities for reasoning, reflection, language and interpretation without requiring the LLM itself to be the agent. In the near future, increasingly capable world models may make it possible to give these architectures much richer models of their environments, actions and consequences. Combined with persistent memory, attention, needs, attachments, self-models and continuing interaction with the world, that makes the progressive-fidelity approach increasingly interesting to explore.

That gives us a very concrete research path: continue developing the theory and building prototypes in parallel, using each generation of technology to add and integrate more of the functionality associated with consciousness, increase the fidelity of the architecture, and see what we learn.

References

[1] Mustafa Suleyman - A warning about ‘model welfare’ https://mustafa-suleyman.ai/a-warning-about-model-welfare

[2] David Chalmers - Could a Large Language Model Be Conscious?
https://www.bostonreview.net/articles/could-a-large-language-model-be-conscious/

[3] David Chalmers - What We Talk to When We Talk to Language Models
https://philarchive.org/rec/CHAWWT-8

[4] OODA Agency Theory - Paper 12, Do You Care? The Inverse Turing Test and Fractured Attachments
https://aystron.ai/papers/paper12/

[5] OODA Agency Theory - Paper 04, Action Realization in Agentic Systems
https://aystron.ai/papers/paper04/

[6] OODA Agency Theory - Paper 05, Artificial Phenomenology and Experiential Structures https://aystron.ai/papers/paper05/

[7] David J. Chalmers - The Conscious Mind: In Search of a Fundamental Theory. Oxford University Press, 1996. https://consc.net/the-conscious-mind/