In a schema-based cognitive architecture the mind is not a program running steps in sequence, but a set of units running together and contending for a scarce resource: compute time. Modelling that contention is a software-engineering problem before it is a cognitive-science one, and it decides whether the architecture stays a theory on paper or actually runs.

The problem

Classical artificial intelligence breaks an agent into modules that call one another: the perceiver hands off to the reasoner, the reasoner to the planner, the planner to the actuator. It is a chain, and a chain has an order. Schema-based architectures reject that order. The idea goes back to Michael Arbib’s schema theory: behaviour arises from the interaction of many perceptual and motor schemas working in parallel, each with its own activity, with no conductor sequencing them.

The sharpest precedent is the Pandemonium that Oliver Selfridge described in 1959: a crowd of demons, small specialised entities, each shouting at a volume proportional to how much it recognises something in the input; a demon higher up the hierarchy listens to the shouting and decides. Recognition is not an algorithm that starts and finishes, but a level of clamour emerging from competition.

Turning all of this into code raises a precise question. If schemas do not call one another in sequence but live in parallel, who decides which schema runs now, and for how long? On a real machine cores are few and threads have to be scheduled. The cognitive metaphor — many units competing — becomes, underneath, a problem of concurrency and resource allocation.

Architecture

A schema-based runtime usually answers by running each schema as a concurrent unit — in practice a thread, or a lightweight unit multiplexed onto a few threads — and introducing a scalar quantity attached to each one: its energy, or activation level. The energy is not cosmetic. It is the currency the system uses to buy compute.

The mechanism rests on three choices:

  • Activation as a finite resource. The system holds a total amount of energy that it continuously redistributes among schemas. A schema relevant to the context draws energy; an irrelevant one loses it. The sum stays bounded, so activating something amounts, in effect, to deactivating something else.
  • Activation-weighted scheduling. The CPU time a schema receives is a function of its energy. It is not the operating-system scheduler that decides who matters more: the cognitive state modulates how much compute each unit gets. The scheduler becomes an actuator of the attention policy.
  • Decoupled communication. Schemas do not invoke one another by name. They publish to and read from a shared space — a blackboard, in the classic vocabulary of the blackboard model — or exchange structured messages. The decoupling is needed because the set of active schemas changes at runtime: you cannot wire a call graph at compile time among units that come and go.

On top of this core you need a way to define schemas without rewriting the runtime each time. Mature implementations pair the C++ engine with a schema-description language and an XML-based message protocol, so the researcher declares a new agent as configuration rather than as system code. A cognitive schema-based architecture of this kind, written in multithreaded C++, was developed by noze in the A.K.I.R.A. framework within the European MindRACES project: https://www.noze.it/en/open-source/akira/.

The critical point

The hard part is not starting the threads: it is the energy-redistribution policy. The whole system’s observable behaviour depends on that policy, and the right policy does not follow from cognitive theory — it has to be tuned.

Three tensions make it delicate.

The first is stability. If energy concentrates too fast on a single schema, the system fixates and ignores the rest of the world; if it disperses, no schema gathers enough compute to finish anything and the agent oscillates without deciding. It is the same trade-off between exploration and exploitation, here in the form of resource management.

The second is the degree of parallelism. The metaphor promises thousands of simultaneous schemas; the hardware sustains far fewer. The number of threads, the cost of context switches and contention over shared data put a hard limit on how close the metaphor gets to the implementation. A shared blackboard is easy to explain but becomes a lock bottleneck when too many schemas write to it at once.

The third is fuzzy causality. Deciding how much to activate a schema needs judgements that are not boolean: how much this input looks like prey, how much that context is dangerous. This is where soft-computing tools come in — fuzzy logic and fuzzy cognitive maps, the fuzzy causal maps introduced by Bart Kosko in 1986 — not as ornament, but as a way to compute the weights that feed the energy redistribution. The causal network among concepts becomes the function that converts perception into activation.

Implications

If activation is the resource and scheduling follows it, one design consequence is that the agent’s behaviour is observed and tuned from the outside by watching the energy, not by reading the code. The record of how active each schema has been over time is the explanation of what the agent was doing: where it put attention, what it ignored, when it shifted focus. It is a form of transparency that comes from the architecture, not bolted on afterwards.

This matters beyond the virtual worlds these frameworks were built for. A system made of units competing for shared resources is governable to the extent that the competition is observable and constraints can be imposed: caps on the energy of certain classes of schemas, priorities that cannot be overridden, a log of who obtained compute and when. These are the same levers needed when the units are not cognitive schemas but processes acting on the world. Concurrency, here, is not an implementation detail to hide: it is the layer at which control is exercised.

Limits

What is described here concerns the runtime’s architecture, not the cognitive quality of what the runtime produces. That schemas compete in an orderly way says nothing about how sensible the emerging behaviours are: a stable activation policy can sustain a foolish agent as well as a capable one. The verification problem also stays open. A system where control flow emerges from competition rather than from a fixed call graph is hard to test with the methods of sequential software: the reachable states depend on a continuous quantity that redistributes itself, and reproducing a behaviour requires reproducing the whole trajectory of the energy. The gap between the metaphor’s promise — thousands of free schemas — and the hardware that runs it does not close with a more elegant abstraction: it is paid in threads, in locks and in compute time.

Cover image: A.K.I.R.A. project logo (noze).