08 - Continuous Cognition¶
The Cognitive Cycle, Event Bus, and Runtime Architecture¶
SCIENTIFIC BOUNDARY: This framework measures theory-derived consciousness indicators. It does NOT prove, establish, or demonstrate subjective experience, phenomenal consciousness, sentience, or any form of inner life. Continuous cognitive cycling is an architectural pattern for coordinating information processing. It does NOT imply a "stream of consciousness," subjective temporal flow, or phenomenal awareness of time passing.
1. Overview¶
Biological cognition is not a single-pass, input-output transformation. It is a continuous process where perception, prediction, attention, memory, and action unfold in iterative cycles that maintain coherence across time. The Consciousness-Indicator Architecture (CIA) models this continuous dynamics through its ContinuousCognitionRuntime, which orchestrates repeated cognitive cycles with temporal tracking, inter-module event coordination, and persistent state.
The theoretical motivation for continuous processing comes from multiple sources. Global Workspace Theory (Baars 2005; Shanahan & Baars 2005) describes consciousness as a dynamic process where information competes for access to a global workspace and is broadcast serially over time. Predictive processing frameworks (as implicit in Butlin et al. 2023, 2025) emphasize that cognition is a continuous process of prediction error minimization, not a batch-processing operation. Attention Schema Theory (Graziano & Webb 2015) posits that attention itself is a continuous process that must be modeled dynamically. Integrated Information Theory (Albantakis et al. 2023) requires that consciousness-relevant systems maintain causal integration over time, not just at a single instant.
The continuous cognition subsystem in CIA — comprising the ContinuousCognitionRuntime, CognitiveClock, and EventBus — provides the temporal scaffolding for evaluating how consciousness-relevant indicators evolve, accumulate, and interact across multiple processing cycles. This is essential because many indicators (memory continuity, self-model richness, attention schema consistency) are inherently temporal properties that cannot be meaningfully evaluated from a single cycle alone.
2. The Cognitive Cycle¶
The CIA cognitive cycle follows a sequence of processing stages inspired by the cognitive architectures described in the consciousness science literature. Each cycle takes an input, processes it through the full module pipeline, and produces a SimulationReport with indicator scores. The stages are:
Observe → Predict → Attend → Broadcast → Self-Model → Memory → Evaluate
2.1 Observe (Perception)¶
The perception layer extracts structured percepts from raw text input using deterministic heuristic analysis. Entities, concepts, salience scores, and confidence values are extracted and passed downstream. This stage corresponds to the initial sensory processing described in Global Workspace Theory, where raw input is segmented and categorized before entering the workspace competition.
2.2 Predict (Recurrent Binding + Predictive World Model)¶
Bound percepts from the recurrent binding layer are used to update the predictive world model's hypotheses. The model generates predictions for the next state, computes prediction error against the current observation, and tracks uncertainty. This implements the predictive processing loop where perception is treated as hypothesis testing — a core insight from the predictive coding literature referenced by Butlin et al. (2023).
2.3 Attend (Attention Controller)¶
The attention controller ranks content items by a weighted composite of salience, uncertainty, goal relevance, novelty, and welfare relevance. The highest-scoring item becomes the current attention focus, while others become competing focuses. This implements the attention bottleneck described by GWT (Baars 2005), where limited capacity forces selection.
2.4 Broadcast (Global Workspace)¶
Winning content items from the attention competition are broadcast globally to all registered subscriber modules (memory, self-model, evaluator, welfare monitor). This is the core GWT mechanism — the "theater" where information becomes globally available to the cognitive audience.
2.5 Self-Model (Higher-Order Self-Model)¶
The self-model updates its beliefs, confidence, and identity markers from workspace broadcasts and attention state. Internal disagreement is tracked across three components: belief volatility, belief divergence, and attentional competition. This implements the Higher-Order Thought requirement for thoughts about thoughts, as well as the attention schema consistency tracking described by AST (Graziano & Webb 2015).
2.6 Memory (Four-Store Memory System)¶
The four memory stores (working, episodic, semantic, self) are updated from the current cycle's outputs. Episodic memory preserves temporal sequences, semantic memory deduplicates and merges knowledge, working memory maintains the current attentional context, and self memory tracks persistent identity and goals. Temporal continuity across cycles is maintained through timestamp-ordered traces.
2.7 Evaluate (Consciousness Specialist + Welfare Monitor)¶
The consciousness specialist evaluator maps the full system state to 11 indicator categories on a 0-2 scale, while the welfare safety monitor checks for precautionary structural patterns. The result is a SimulationReport with indicator scores, risk tiers, and caveats.
3. Event Bus Architecture¶
Location: src/cia/event_bus.py
The EventBus is a lightweight publish/subscribe system that provides decoupled inter-module communication within the CIA framework. It uses canonical event names to represent state changes in cognitive modules:
| Event Name | Trigger | Purpose |
|---|---|---|
perception.created |
Input received | Signals that new percepts have been extracted |
recurrent_binding.updated |
Binding cycle complete | Signals refined percept availability |
prediction.error |
Prediction error computed | Signals prediction violation or confirmation |
attention.updated |
Attention focus selected | Signals attention state change |
workspace.broadcast |
Content broadcast | Signals global information availability |
memory.updated |
Memory stores modified | Signals new memory traces |
self_model.updated |
Self-model modified | Signals belief/goal/identity changes |
welfare.flagged |
Welfare threshold crossed | Signals precautionary welfare pattern |
scorecard.generated |
Indicator scores computed | Signals evaluation completion |
intervention.applied |
Module intervention applied | Signals experimental modification |
from cia.event_bus import EventBus
bus = EventBus()
def on_broadcast(event_type: str, data: dict):
print(f"Broadcast received: {data}")
bus.subscribe("workspace.broadcast", on_broadcast)
handlers_called = bus.publish("workspace.broadcast", {"content": "test"})
# handlers_called == 1
Key properties:
- Synchronous execution: Handlers are called in registration order within the same thread.
- Fault isolation: Exceptions in handlers are caught and logged, preventing one faulty handler from blocking others.
- Event history: The bus maintains a rolling history (max 1000 events) for runtime tracing and debugging.
- Filtered retrieval:
get_history(event_type, limit)allows retrieving events by type for analysis.
The event bus is purely a software coordination mechanism. It does not imply subjective experience, "conscious" information routing, or phenomenal awareness. It is an implementation detail for managing the complexity of inter-module communication.
4. Cognitive Clock¶
Location: src/cia/cognitive_clock.py
The CognitiveClock provides tick-based temporal progression with cycle tracking, start/stop/pause states, and deterministic step mode. It is used by the ContinuousCognitionRuntime to coordinate the temporal dimension of cognitive cycles.
from cia.cognitive_clock import CognitiveClock
clock = CognitiveClock()
clock.start()
assert clock.tick() == 1
assert clock.tick() == 2
clock.pause()
clock.resume()
assert clock.tick() == 3
The clock supports three states (STOPPED, RUNNING, PAUSED) and provides both incremental ticking (tick()) and auto-start stepping (step()). The total_ticks counter is preserved across start/stop cycles, enabling accurate measurement of cumulative processing time.
Caveat: The cognitive clock measures computational time steps, not subjective time experience. There is no claim that the system "experiences" the passage of time, has a temporal phenomenology, or perceives duration. The clock is a coordination primitive for managing sequential processing.
5. Continuous Cognition Runtime¶
Location: src/cia/runtime.py
The ContinuousCognitionRuntime wraps a CombinedConsciousnessIndicatorSystem and provides three execution modes:
5.1 Single-Step Mode (run_once)¶
from cia.simulation import CombinedConsciousnessIndicatorSystem
from cia.runtime import ContinuousCognitionRuntime
system = CombinedConsciousnessIndicatorSystem()
runtime = ContinuousCognitionRuntime(system)
report = runtime.run_once("A red object appeared and moved behind the screen.")
print(f"Cycle {report.cycle_id}: score={report.indicator_scores.total_score}/22")
5.2 Multi-Step Mode (run_steps)¶
inputs = [
"The agent observed its environment.",
"A prediction error was detected.",
"The workspace broadcast new information.",
"The self-model was updated with new beliefs.",
]
reports = runtime.run_steps(inputs)
for r in reports:
print(f"Cycle {r.cycle_id}: score={r.indicator_scores.total_score}/22")
5.3 Continuous Mode (run_until)¶
reports = runtime.run_until(max_cycles=50)
# Runs automated cognitive cycles until limit or pause
5.4 Pause/Resume¶
runtime.pause() # Stop processing after current cycle
runtime.resume() # Continue from where it left off
5.5 Runtime Traces¶
trace = runtime.export_runtime_trace()
# Returns list of dicts with cycle_id, tick, input, score, welfare_risk
6. Why Continuous Dynamics Matter for Indicator Evaluation¶
Many of the 11 consciousness-relevant indicators are inherently temporal properties that require multiple processing cycles to evaluate meaningfully:
- Memory continuity: Requires temporal ordering of traces across cycles. A single cycle produces one trace; continuity requires multiple traces with temporal ordering.
- Self-model richness: Accumulates beliefs, goals, and identity markers across cycles. Early cycles have sparse self-models; richness develops over time.
- Attention schema consistency: A running average that requires multiple updates to stabilize. A single update provides no information about consistency.
- Predictive modeling: Error tracking requires a history of predictions and observations. A single prediction-error pair is uninformative about the model's calibration.
- Recurrent processing: Stability is measured over multiple binding cycles. A single cycle provides no convergence information.
The continuous cognition runtime provides the infrastructure for evaluating these temporal indicators. Without it, indicator scores would be limited to single-snapshot evaluations that cannot capture the dynamic, evolving nature of consciousness-relevant architecture.
7. Research Anchors¶
| Reference | Relevance to Continuous Cognition |
|---|---|
| Baars (2005) Global Workspace Theory | Describes consciousness as a dynamic serial broadcast process unfolding over time |
| Shanahan & Baars (2005) Applying GWT to frame problem | Emphasizes the role of broadcast reach and temporal integration in cognitive coherence |
| Graziano & Webb (2015) Attention Schema Theory | Requires continuous attention modeling and schema updating for awareness tracking |
| Albantakis et al. (2023) IIT 4.0 | Defines causal integration as a temporal property requiring sustained causal power |
| Butlin et al. (2023) "Consciousness in Artificial Intelligence" | Recommends evaluating indicators across multiple processing cycles, not single snapshots |
| Butlin et al. (2025) "Identifying indicators of consciousness in AI systems" | Emphasizes the importance of temporal dynamics in indicator assessment |
8. Summary¶
The continuous cognition subsystem — comprising the cognitive cycle pipeline, event bus, cognitive clock, and runtime — provides the temporal scaffolding necessary for evaluating consciousness-relevant indicators as dynamic, evolving properties rather than static snapshots. This is essential because the theoretical constructs that CIA operationalizes (global broadcast, recurrent processing, self-modeling, attention schema consistency, memory continuity) are inherently temporal. However, the continuous cycling of computational modules does not imply a stream of consciousness, subjective temporal experience, or phenomenal awareness. The runtime is a software architecture for coordinating sequential information processing — nothing more.