DIKWP+BUG Architecture for Purpose-Aware Cognitive Computing

Abstract

Purpose-aware AI systems are increasingly deployed in safety-critical, multi-agent, and human-facing environments, where they must transform heterogeneous data into timely, explainable, and goal-aligned decisions under uncertainty. Existing architectures often couple perception, reasoning, communication, and security only at the pipeline level. This creates a research gap in unified semantic transformation, purpose-oriented judgment, bounded imperfection handling, and semantic self-protection. To address this gap, this paper proposes a DIKWP+BUG semantic–cognitive reference architecture for artificial-consciousness-oriented computing, without claiming definitive artificial consciousness. The architecture represents cognition through the Data–Information–Knowledge–Wisdom–Purpose (DIKWP) model and uses BUG theory to model bounded approximation, incomplete evidence, and confidence miscalibration in cross-dimensional reasoning. The model is mapped to an Artificial Consciousness Processing Unit (ACPU) reference substrate, an Artificial Consciousness Operating System (ACOS), a DIKWP semantic communication subsystem, and a concept–semantic fused security subsystem. The components are implemented through runtime emulation and evaluated in smart-city governance, autonomous-driving, and medical-triage simulations. Compared with selected baselines, the prototype increased cognitive throughput from $4.5\mathrm{k}$ to $7.8\mathrm{k}$ logged events, reduced perception–action latency from $340\mathrm{ms}$ to $120\mathrm{ms}$, reduced CPU utilization from $95\%$ to $68\%$, lowered smart-city congestion duration by $30\%$, improved emergency response time by approximately $40\%$, achieved 0 collisions versus approximately $2/10$ baseline IoV runs, and improved medical-triage accuracy from $85\%$ to $92\%$. These online-runtime results provide initial feasibility evidence under controlled simulation conditions; they do not include offline model-preparation costs and therefore should not be interpreted as end-to-end lifecycle speedups. Matched-compute ablation, statistical benchmarking, hardware prototyping, and real-world validation remain future work.

1. Introduction

AI systems are increasingly embedded in operational environments in which decisions must be made from heterogeneous data streams, communicated across agents, and constrained by human goals, safety requirements, and social norms [1,2,3,4,5]. Although recent progress in large language models, representation learning, and neurosymbolic AI has improved pattern recognition, knowledge processing, and language-mediated reasoning, many deployed systems still separate perception, reasoning, communication, and security into loosely coupled modules [6,7,8,9,10]. As a result, such systems may respond efficiently to familiar tasks but remain fragile when confronted with incomplete observations, conflicting evidence, adversarial inputs, or competing operational purposes [3,8,10,11].

The motivation for this study is therefore practical as well as theoretical. In domains such as smart-city management, autonomous driving, and clinical decision support, the problem is not simply to extract accurate features from data; it is to transform data into actionable, explainable, and goal-aligned judgments under strict latency and safety constraints [11,12,13]. For example, a traffic-governance agent must coordinate congestion control with emergency response, a vehicle must reconcile local perception with communicated hazards, and a medical-triage assistant must balance incomplete symptoms, uncertain test results, and patient-safety priorities. These settings require a full-stack architecture in which computation, communication, reasoning, and security are organized around a common semantic-purpose model rather than appended as independent layers.

Accordingly, the present work is motivated by a gap in existing artificial-consciousness and cognitive-system research: there is still no widely accepted architecture that jointly models semantic transformation, purpose-oriented judgment, bounded imperfection, semantic communication, and internal semantic security in one operational framework [1,2,5,8,9,10]. We address this gap by developing a DIKWP+BUG semantic–cognitive architecture that explicitly links the Data–Information–Knowledge–Wisdom–Purpose progression with controlled approximation and self-correction. The goal is not to claim definitive artificial consciousness, but to provide a testable reference architecture for purpose-aware cognitive computing.

The DIKWP model has been proposed as a purpose-extended semantic–cognitive framework for artificial intelligence and artificial consciousness, augmenting the conventional DIKW hierarchy with an explicit Purpose dimension [14,15,16,17,18]. In this formulation, data, information, and knowledge are progressively transformed into higher-order evaluative and goal-oriented representations through interactions among five interrelated elements: Data, Information, Knowledge, Wisdom, and Purpose [14,15,18]. Recent DIKWP studies describe this process in terms of interacting cognitive, semantic, and conscious spaces rather than a purely linear pipeline, thereby emphasizing cross-dimensional transformation, uncertainty handling, and context-sensitive reasoning [15,16,17]. By explicitly incorporating wisdom and purpose, the framework provides a basis for modeling value-aware reasoning, long-horizon planning, and purpose-aligned decision support beyond conventional data-centric AI pipelines [14,18,19]. Applications reported in healthcare, human–machine semantic communication, and legal reasoning further suggest that DIKWP can serve as a structured basis for explainable and purpose-aware intelligent systems [16,17,18,19].

Complementing the DIKWP model, the BUG theory of consciousness has been proposed as a theoretical perspective in which bounded and imperfect information processing contributes to the emergence of conscious experience rather than being treated solely as error. Within this view, simplifications, partial abstractions, and internal inconsistencies are interpreted as functionally relevant consequences of limited cognitive resources, enabling an agent to construct workable, though incomplete, semantic models under conditions of complexity and uncertainty. This perspective is conceptually consistent with recent work on the illusion of explanatory depth, which shows that people often overestimate the depth of their understanding of causal phenomena, as well as with contemporary research on constructive memory, which characterizes remembering as a reconstructive process that supports simulation and adaptation while also giving rise to memory distortions [20,21]. Related work on the narrative self further suggests that episodic recall is shaped by self-related construal, semantic selection, and scenario construction rather than by verbatim replay alone [22]. Accordingly, in the present study, the BUG theory is used as a conceptual lens for modeling cognitive imperfection as a potential source of abstraction, coherence formation, and heuristic decision-making in artificial consciousness, while recognizing that BUG-specific literature remains at an early stage of development.

By integrating BUG theory into AC design, the present study treats bounded and imperfect cognition as a potentially functional design principle rather than as a defect to be eliminated outright [23]. In complex domains, exhaustive reasoning is often computationally prohibitive, and recent work on rationality and irrationality in AI suggests that limited, heuristic, or approximate reasoning can, in some settings, be instrumentally useful for timely decision-making [23,24]. From this perspective, a BUG-aware AC system may tolerate partial abstractions, provisional assumptions, and uncertainty while maintaining mechanisms for calibration, revision, and consistency checking [23]. This orientation is also compatible with recent empirical work reporting positive associations between cognitive flexibility and creativity [25], as well as with contemporary accounts of constructive memory, which characterize recall as a reconstructive process that supports future simulation and adaptation while also giving rise to distortion and error [21,22]. Accordingly, within the present framework, BUG theory is used as a conceptual lens for modeling ambiguity tolerance, inconsistency recovery, and adaptive decision-making in artificial consciousness rather than as a claim that such mechanisms have already been fully validated in AC systems [21,23].

Against this background, and building on recent efforts to operationalize and evaluate artificial consciousness [5,26,27,28], the present study addresses the following research gaps:

G1.

Existing AI architectures still lack a unified semantic–cognitive model that explicitly connects data acquisition, information interpretation, knowledge organization, wisdom-level evaluation, and purpose-oriented control.

G2.

Current cognitive architectures and applied AI systems do not sufficiently operationalize bounded imperfection as a controllable design factor for timely reasoning under uncertainty.

G3.

Semantic communication and internal semantic security are often treated as external add-ons rather than as intrinsic components of a purpose-aware cognitive cycle.

G4.

Available evaluations of artificial-consciousness-oriented systems remain limited in demonstrating how a shared semantic-purpose architecture behaves across multiple simulated domains and ablated configurations.

To address these gaps, this paper makes the following research contributions:

C1.

It formalizes the DIKWP semantic–cognitive model through mathematical definitions of cross-dimensional content spaces, transformation functions, content-network structure, and semantic flux.

C2.

It introduces BUG-aware formalization into the DIKWP processing loop, allowing bounded approximation, confidence miscalibration, and semantic inconsistency to be modeled, monitored, and corrected.

C3.

It proposes a full-stack DIKWP+BUG architecture integrating ACPU, ACOS, DIKWP semantic communication, and DIKWP concept–semantic fused security in one operational framework.

C4.

It implements a runtime emulation and evaluates the architecture in smart-city governance, autonomous-driving, and medical-assistant simulations, reporting quantitative comparisons with selected baseline configurations.

C5.

It clarifies the boundary between online runtime cost and offline model-preparation cost and adds a statistical reporting protocol to support more reproducible follow-up studies.

Taken together, these contributions provide initial evidence for the feasibility of the proposed architecture in the tested settings, while not yet constituting a standardized validation of artificial consciousness.

The remainder of this paper is organized as follows. Section 2 reviews related work and theoretical background, including major consciousness theories and recent research on artificial consciousness. Section 3 presents the formal definitions of the DIKWP model and its integration with BUG theory. Section 4 describes the proposed AC ecosystem architecture, including ACPU, ACOS, DIKWP-SC, and DIKWP-CSFS. Section 5 introduces the prototype implementation and simulation environment. Section 6 reports the experimental results, comparative analysis, limitations, and future research directions. Section 7 concludes the paper.

2. Related Work

2.1. Consciousness Theories in AI and Cognitive Science

The study of consciousness, and its potential artificial instantiation, has developed across cognitive science, neuroscience, philosophy of mind, and artificial intelligence. Among the most influential accounts, Global Workspace Theory (GWT) holds that numerous specialized processors operate in parallel, while only a limited subset of contents gains access to a global workspace from which information can be broadcast across the system [29,30,31]. GWT has also inspired computational architectures in AI, especially workspace-based models designed to coordinate perception, memory, attention, and action selection [32]. From this perspective, the DIKWP framework can be interpreted as functionally analogous to a workspace architecture: the Data, Information, and Knowledge dimensions support distributed acquisition and preprocessing, whereas the Wisdom and Purpose dimensions provide higher-order integration, evaluation, and directive control. Rather than claiming a strict equivalence, it is more precise to state that DIKWP offers a purpose-sensitive extension of the global-workspace idea for artificial consciousness research.

Integrated Information Theory (IIT) provides a distinct but complementary account by relating consciousness to the irreducible integration of information within a system. In Tononi’s formulation, consciousness corresponds to a system’s capacity to integrate information, while later versions of IIT further formalize how differentiated yet unified experience can be generated by specific causal structures [33,34]. This emphasis on integration resonates with the dimensional transformations proposed in DIKWP. The progression from Data to Information, Knowledge, and Wisdom may be understood as a sequence of increasingly integrated semantic and cognitive abstractions, whereas the Purpose dimension constrains these transformations in light of system goals. In this sense, DIKWP extends the discussion beyond integration alone by foregrounding goal-directed organization and context-sensitive action selection.

Higher-Order Thought (HOT) theory shifts attention from integration to meta-representation. On this view, a mental state becomes conscious when it is accompanied by an appropriate higher-order representation, that is, when the system in some sense has a thought about its own first-order state [35,36]. Although HOT originated in the philosophy of mind, its architectural implication for artificial systems is clear: conscious processing requires mechanisms for self-monitoring and meta-cognition. The DIKWP model is compatible with this requirement because the Wisdom dimension can be interpreted as a locus for reflective assessment of knowledge, while the Purpose dimension can be understood as supporting the evaluation and regulation of goals, priorities, and action criteria. Under this interpretation, DIKWP processes not only external inputs but also higher-order appraisals of its own internal states.

A further relevant tradition comes from systems engineering and creativity research, especially TRIZ, the Theory of Inventive Problem Solving, which was developed as a systematic approach to resolving contradictions in invention and design [37]. Recent work extends this logic into the DIKWP-TRIZ framework, where inventive problem solving is linked to purpose-guided transformations across the Data, Information, Knowledge, Wisdom, and Purpose dimensions [38]. This extension is especially relevant to artificial consciousness research because it addresses a question that classical consciousness theories often leave underdeveloped: how a system should respond to conflicting constraints, incomplete information, and novel task demands. In this respect, DIKWP-TRIZ contributes a methodological basis for contradiction management and adaptive invention within a broader cognitive architecture.

Taken together, these theories provide complementary resources for theorizing artificial consciousness. GWT emphasizes global availability and coordinated broadcast, IIT emphasizes irreducible integration, HOT highlights meta-representation and self-monitoring, and TRIZ contributes a structured approach to contradiction resolution and creative problem solving [29,33,35,37]. The DIKWP framework synthesizes several of these concerns by combining hierarchical semantic transformation, higher-order evaluation, and explicit purposiveness [16,18]. Accordingly, the present study adopts DIKWP not as a literal substitute for existing theories of consciousness, but as an integrative scaffold for implementing a purpose-sensitive artificial consciousness architecture. In addition, this study draws on BUG-theory-related discussions within the DIKWP research line to examine the possible cognitive value of incompleteness and processing limitations; however, because the currently available BUG-theory sources are still largely conceptual or early-stage technical publications, this component should be regarded as an emerging rather than fully consolidated line of theory.

2.2. DIKWP Model: Data–Information–Knowledge–Wisdom–Purpose

The DIKWP model extends the classical DIKW hierarchy by introducing Purpose as a fifth element. Unlike the conventional DIKW formulation, which primarily emphasizes progressive abstraction from data to wisdom, DIKWP makes explicit the role of goal orientation in organizing perception, interpretation, reasoning, and action [15,16,18,19,39,40]. In this study, DIKWP is treated as a structured yet dynamic semantic–cognitive space, in which the five elements are analytically distinguishable but operationally interconnected.

• Data (D). Data refer to raw observations, signals, or symbols that record properties of objects or events but are not yet sufficiently contextualized for higher-level reasoning [39,40]. In an artificial system, data may include sensor streams, logs, state variables, or discrete input tokens. The transformation from data to information may be represented as $T_{D\to I}$, through which raw observations $d\in D$ are filtered, aggregated, or encoded into interpretable statements $i\in I$ [15,16]. For example, a sequence of temperature readings constitutes data, whereas the statement “the room temperature is 18 °C” already reflects a more structured representation. Data therefore form the initial dimension of semantic–cognitive processing and provide the material basis for subsequent interpretation.
• Information (I). Information is data that have been contextualized, differentiated, or related to other semantic units so that a meaningful state, relation, or pattern becomes interpretable [15,39,40]. Information therefore does not merely accumulate data; it organizes data under a schema, intention, or relational frame. The mapping $T_{I\to K}$ transforms information into knowledge through comparison, integration, and generalization. For instance, the propositions “the room is 18 °C”, “18 °C is below the comfort threshold”, and “20 °C is preferable for comfort” may, together, support the conclusion that “the room is colder than optimal.” Information thus serves as the immediate semantic bridge between raw input and conceptual understanding.
• Knowledge (K). Knowledge denotes organized information that has been stabilized into rules, models, categories, causal relations, or procedural structures that support inference and prediction [15,39,40]. In AI systems, knowledge may be instantiated in ontologies, knowledge graphs, rule sets, or learned models. Knowledge is more durable than transient information because it captures structured regularities rather than isolated observations. The transformation $T_{K\to W}$ maps knowledge to wisdom by subjecting it to contextual evaluation, trade-off analysis, and value-sensitive judgment [15,16]. Knowledge therefore answers what is the case and how things are related, but not yet what ought to be done in a particular situation.
• Wisdom (W). Wisdom refers to contextual insight and judgment: the capacity to determine which knowledge should be applied, when it should be applied, and under what practical, ethical, or long-horizon constraints [15,39,40]. In DIKWP, wisdom is not simply an enlarged stock of knowledge, but an evaluative dimension that integrates knowledge with values, feasibility, and consequence awareness [16]. In an artificial-consciousness system, wisdom may be implemented as a deliberative mechanism that balances competing considerations—for example, comfort, safety, efficiency, and user preference—before selecting a course of action. From the knowledge that a room is cold, wisdom may infer that gradual heating is preferable because it better balances immediate comfort with energy efficiency. Wisdom is also the dimension most relevant to contextual correction, since it can override otherwise valid but contextually inappropriate knowledge application.
• Purpose (P). Purpose is the distinctive fifth element that differentiates DIKWP from classical DIKW. It denotes the aims, intentions, priorities, or goal conditions that orient the entire cognitive process [15,16,18,19]. Purpose is not merely the terminal output of reasoning; it is also a regulatory condition on reasoning. It influences what data are attended to, what information is extracted, which knowledge is activated, and what counts as a wise decision in a given context [16,18,19]. Formally, $T_{W\to P}$ may be understood as the crystallization of evaluated understanding into goal-directed intent, while top-down feedback from P to D, I, K, and W ensures alignment between ongoing cognition and current objectives. For an autonomous medical assistant, for example, a purpose such as maximizing patient well-being or minimizing unnecessary intervention would directly affect diagnostic thresholds, decision priorities, and action policies.

A critical feature of DIKWP is that these five elements are transformable and interconnected rather than strictly siloed. Although the canonical direction may be written as $D\to I\to K\to W\to P$, actual processing need not remain linear. Cross-dimensional jumps, many-to-many mappings, and cyclic feedback are possible. Information may directly trigger wisdom-level assessment; purpose may reshape data selection through attention and prioritization; and purpose-driven action may generate new data, thereby closing a full cognitive loop [16,18,19]. For this reason, DIKWP is better understood as a semantic–cognitive network than as a one-way ladder.

From this networked perspective, content may propagate across the DIKWP elements with different densities, speeds, and degrees of reinterpretation. In the present study, this dynamic is described as semantic flux, namely the extent to which content traverses, transforms, and recirculates across D, I, K, W, and P. Used in this sense, semantic flux is not assumed here to be a fully standardized metric, but rather an analytic descriptor of inter-element propagation that will be formalized further in Section 3. Overall, DIKWP provides a structured yet fluid semantic–cognitive framework for artificial consciousness by distinguishing the five elements while preserving their dynamic interaction.

2.3. BUG Theory of Consciousness and Semantic Imperfections

Within the recent DIKWP literature, BUG theory is presented as a conceptual account according to which conscious-like cognition emerges partly from bounded, approximate, and semantically compressed processing rather than from perfectly complete representation. In this view, an agent does not possess exhaustive access to the world; instead, it stabilizes on partial but actionable interpretations that are sufficiently coherent to guide judgment and behavior. Because the currently available BUG-theory sources are primarily early-stage conceptual writings and technical reports, it is methodologically more precise to treat BUG theory here as an emerging framework for artificial-consciousness design rather than as a consolidated empirical theory within mainstream cognitive science.

A central proposition of this framework is that cognition routinely operates under an illusion of completeness. Agents often experience their own representations as sufficiently deep or unified even when those representations are fragmentary. This claim is broadly consistent with the well-established illusion of explanatory depth, according to which people commonly overestimate how well they understand mechanisms and complex phenomena [41]. It also aligns with bounded-rationality accounts, in which limited time, memory, and computational capacity force agents to satisfy rather than optimize [42]. From a BUG-theory perspective, such incompleteness is not merely a defect; it is a functional precondition for timely interpretation and decision [41,42].

The theory further emphasizes that semantic simplification arises from resource limitation. When attentional, mnemonic, or computational resources are finite, cognition must rely on heuristics, abstraction, and pattern recognition rather than exhaustive search [42,43]. Contemporary decision theory likewise shows that heuristics deliberately ignore part of the available information while remaining adaptive in many environments [43]. BUG theory therefore reframes semantic imperfection as a functional property of intelligent systems: efficiency and generalization are obtained at the cost of occasional distortion, omission, or edge-case failure. The same logic also implies a limited form of cognitive relativity, insofar as agents with different priors, compression strategies, or computational constraints may construct different semantic pathways through the same problem space [42,43].

This claim has a useful, though limited, analogue in contemporary AI. Large language models and related statistical learners rely on compressed internal representations that often appear semantically coherent while remaining vulnerable to hallucination and factual drift [44,45]. These compressed representations can then be redeployed as semantic tools in language generation, planning, and self-description. The BUG literature explicitly interprets such outputs as machine-level counterparts of illusory semantic completion, especially in mappings between semantic and conceptual spaces. However, this analogy should not be overstated: hallucination in LLMs demonstrates the practical consequences of compressed probabilistic inference, but it does not by itself establish machine consciousness [44,45].

BUG theory also intersects with contemporary constructive accounts of memory and perception. Cognitive science has repeatedly shown that memory is reconstructive rather than a literal replay of stored traces, and that such reconstruction can be both adaptive and error-prone [46,47]. Similarly, predictive-processing approaches describe perception as an inferential construction generated under uncertainty rather than as a transparent copy of external reality [48,49]. These lines of work lend indirect support to BUG theory’s broader suggestion that conscious experience depends on organized approximation, selective abstraction, and context-sensitive narrative stabilization rather than on complete fidelity to the world [46,47,48,49].

Some BUG-theory writings extend this logic to stronger claims about durable machine identity, transferable memory patterns, or even digital immortality. For a journal article, however, such claims should be treated as speculative extrapolations rather than established consequences of the theory. Philosophical work on mind uploading and transhumanism makes clear that questions of survival and personal identity remain unresolved even if psychological patterns could in principle be reproduced computationally [50,51]. Accordingly, the present study does not treat digital immortality as a premise of artificial consciousness, but only notes it as a possible philosophical extension of the BUG framework [50,51].

In the present framework, BUG theory is operationalized not as uncontrolled error, but as bounded imperfection within DIKWP transformations. At the $T_{D\to I}$ stage, this may include selective forgetting, smoothing, or attentional compression; at the $T_{I\to K}$ stage, it may include heuristic generalization, probabilistic categorization, or approximate semantic binding; and at higher dimensions it may appear as preference-sensitive simplification in judgment and action selection. To prevent such imperfections from degenerating into unsafe hallucination or semantic drift, they must be coupled with explicit mechanisms for semantic security, controllability, alignment, and external verification [45,52,53]. This is consistent with recent DIKWP proposals on external semantic security and ACOS-oriented concept–semantic fusion, which treat abstraction-induced incompleteness as something to be managed rather than eliminated outright [52].

Overall, BUG theory shifts the design objective of artificial consciousness away from the classical ideal of exhaustive correctness and toward the management of productive approximation. Its contribution is therefore primarily architectural: it suggests that useful artificial consciousness may require a controlled balance between compression and correction, between semantic flexibility and external constraint, and between rapid abstraction and reliable grounding [44,45,52,53].

2.4. Existing Artificial Consciousness Architectures and the Need for Integration

Research on artificial consciousness has developed along several partially overlapping lines, including classical cognitive architectures, brain-inspired hardware, and recent autonomous AI systems. Surveys of cognitive architectures show that the mainstream focus has been on modeling core cognitive capacities—such as perception, attention, memory, learning, reasoning, and action selection—within unified computational frameworks [54,55]. Representative systems such as Soar, ACT-R, and LIDA exemplify this tradition. LIDA, in particular, organizes cognition around a recurrent cognitive cycle in which selected contents become globally available to other modules, reflecting its connection to Global Workspace Theory [32,56,57,58]. These architectures remain highly relevant to artificial-consciousness research; however, their primary contribution lies in cognitive organization and software realization rather than in full-stack hardware–operating-system co-design for purpose-sensitive semantic processing.

Another important line of work concerns neuromorphic and brain-inspired hardware. Platforms such as SpiNNaker and IBM TrueNorth demonstrate that massively parallel, event-driven, and energy-efficient neural computation can be implemented in specialized hardware rather than relying exclusively on conventional von Neumann execution [59,60,61]. This literature is highly relevant to any serious attempt at scalable artificial consciousness because it addresses the physical execution substrate of brain-like computation. At the same time, its main emphasis is on spiking computation, routing, scalability, and energy efficiency, not on an explicit semantic hierarchy linking perceptual input to information, knowledge, judgment, and purpose. Neuromorphic hardware is therefore best understood as a complementary enabling substrate rather than as a complete cognitive–semantic architecture in its own right [59,60,61].

A further limitation in the existing literature concerns security, controllability, and communication in open environments. Recent surveys on AI-agent security and adversarial machine learning show that autonomous agents face risks from multi-step input manipulation, unsafe tool use, compromised external resources, poisoning, and broader lifecycle vulnerabilities [62,63,64]. In parallel, semantic communication research has shown that once communication is organized around meaning, knowledge alignment, and task relevance rather than raw bit transmission, new attack surfaces emerge at the levels of semantic encoders, knowledge bases, and multi-agent coordination [9,65]. Yet these bodies of work have largely evolved in parallel. They typically address robustness, secure communication, or controllability as adjacent concerns, rather than as internal cross-dimensional consistency conditions within a consciousness-oriented architecture. Recent DIKWP-based studies begin to move in this direction by explicitly connecting semantic security and controllability to higher-level cognitive organization [52,66].

Finally, applied intelligent systems such as autonomous driving platforms and healthcare AI agents already exhibit partial forms of integration, but usually in a domain-specific and function-oriented manner. Current autonomous-driving surveys describe modular or layered systems organized around perception, localization, prediction, planning, and control, alongside newer end-to-end approaches [4,67]. Recent healthcare-agent reviews likewise frame medical AI agents in terms of planning, action, reflection, and memory [13]. These systems are increasingly capable, but they do not typically rely on a shared semantic layer that explicitly reconciles cross-module meaning, long-horizon judgment, and top-level purpose. Recent DIKWP-driven work in smart healthcare suggests one possible route toward such integration, but this direction remains comparatively recent relative to the broader literature on cognitive architectures, neuromorphic computing, and applied AI systems [18].

Table 1. Summary of representative studies and system classes related to artificial-consciousness-oriented architectures.

Study/System Class	Approach Used	Major Findings or Contribution	Potential Limitations Relative to This Study
Classical cognitive architectures such as Soar, ACT-R, and LIDA [54,55,56,57,58]	Unified software architectures for perception, memory, learning, reasoning, attention, and action selection	Demonstrate that cognition can be organized through recurrent cycles, symbolic reasoning, memory structures, and global-workspace-like broadcast	Mainly emphasize cognitive organization and software realization; less focused on purpose-explicit semantic hierarchy, semantic communication, security fusion, and hardware–OS co-design
Neuromorphic and brain-inspired hardware such as SpiNNaker and TrueNorth [59,60,61]	Massively parallel, event-driven, and energy-efficient neural computation on specialized hardware	Provide scalable physical substrates for brain-like computation and low-power neural processing	Do not by themselves define a semantic–cognitive hierarchy linking data, information, knowledge, wisdom, and purpose
AI-agent security and adversarial machine-learning studies [62,63,64]	Taxonomies and mitigation strategies for adversarial input, poisoning, tool misuse, compromised resources, and lifecycle vulnerabilities	Clarify major threat classes and the need for robust security controls in autonomous AI systems	Usually treat security as a protection layer rather than as an internal semantic consistency mechanism of a cognitive cycle
Semantic-communication and semantic-security studies [9,52,65,66]	Meaning-oriented communication, knowledge alignment, semantic privacy, and controllability mechanisms	Show that communication can be organized around meaning, task relevance, and semantic trust rather than raw bit transmission alone	Often focus on communication or security separately, without full integration with purpose-oriented cognition and runtime architecture
Applied autonomous-driving and healthcare-agent systems [4,13,18,67]	Domain-specific perception–planning–control pipelines, clinical decision-support systems, and agentic planning/memory structures	Demonstrate practical value in embodied control and medical decision support under task-specific constraints	Usually rely on domain-specific integration and do not provide a general DIKWP-style semantic-purpose model across domains
DIKWP-based purpose-aware studies [14,15,16,17,18,19]	Purpose-extended DIKW modeling, uncertainty handling, semantic communication, healthcare reasoning, and legal reasoning	Provide theoretical and applied evidence that purpose can structure semantic transformation and explainable decision support	Prior studies do not yet provide a unified ACPU–ACOS–communication–security runtime emulation evaluated across multiple simulated domains

summarizes the main studies and system classes reviewed in Section 2.4 in terms of approach, findings, and limitations.

The comparison in Table 1 shows that existing research has made substantial progress along several important but partly separate directions. Cognitive architectures provide reusable mechanisms for memory, attention, and action selection, yet they are not usually designed as full-stack semantic-purpose systems. Neuromorphic platforms address the execution substrate, but they do not specify how raw signals should be transformed into purpose-aligned judgments. Security and semantic-communication studies identify important risks and protocols, but they often remain external to the core cognitive loop. Applied autonomous-driving and healthcare systems demonstrate domain effectiveness, but their integration is usually pipeline-specific rather than organized around a general semantic–cognitive mesh. DIKWP studies provide the closest theoretical foundation for the present work, yet prior DIKWP-based studies have not combined BUG-aware bounded imperfection, semantic communication, concept–semantic fused security, and runtime emulation in one cross-domain architecture. This gap motivates the integrative design adopted in the present study.

3. Theoretical Framework: DIKWP Semantic Model and BUG Formalization

In this section, we present the formal underpinnings of our approach. First, we define the DIKWP model in mathematical and computational terms, introducing formalisms for dimensions and transformations (Section 3.1). Next, we incorporate the BUG theory into this model, providing a formal perspective on how cognitive “bugs” can be represented and managed (Section 3.2). Finally, we explain how these elements come together, describing the integrated DIKWP+BUG semantic–cognitive framework that will inform the system architecture (Section 3.3).

Unless otherwise stated, the equations in this section are author-formulated modeling definitions used to operationalize the cited DIKW/DIKWP, cognitive-architecture, bounded-rationality, and semantic-security literature [14,15,16,18,39,40,42,43,52,54,55]. They should therefore be read as a formalization of the proposed architecture rather than as previously standardized equations. In the following formalization, $f_{DI}$, $f_{IK}$, $f_{KW}$, and $f_{WP}$ operationalize the conceptual transformations $T_{D\to I}$, $T_{I\to K}$, $T_{K\to W}$, and $T_{W\to P}$, respectively.

3.1. Formalization of the DIKWP Semantic–Cognitive Model

Building on the DIKWP extension of the DIKW hierarchy, we define a set of five content spaces corresponding to the DIKWP dimensions [14,15,16,18,19,39,40]:

• Data space (D). Let D denote the data space. Elements of D (denoted $d_i$) can be raw sensory readings, bits, signals, or primitive facts. We can consider D to be a multi-dimensional space. For instance, if the system has multiple sensors, each sensor’s reading may be treated as a dimension.
• Information space (I). Let I denote the information space. Elements $i_j\in I$ carry meaning. Formally, consistent with common tuple- or proposition-based representations used in symbolic knowledge representation and DIKW-style modeling, we can model an information element as a contextualized tuple [15,16,39,40]. For example,

  $$i_j=(\mathrm{entity},\mathrm{attribute},\mathrm{value},\mathrm{timestamp}),$$

  (1)

  derived from raw data. We assume there is a transformation, adapted from the DIKWP account of Data-to-Information conversion [15,16,18],

  $$f_{DI}:D\to I,$$

  (2)

  which may be many-to-one and maps data to information, representing interpretation or pattern extraction. In practice, $f_{DI}$ may be implemented by signal processing algorithms, feature extraction, or simple recognition procedures such as edge detection in images or named entity recognition in text.
• Knowledge space (K). Let K denote the knowledge space. We treat knowledge as a collection of interconnected concepts, rules, or embeddings. An element $k_k\in K$ might be represented by a node in a knowledge graph or a vector in a latent semantic space. A key aspect of K is structure: relationships such as causality, hierarchy, and correlation between information pieces. Following DIKWP treatments of information aggregation and knowledge construction [15,16,18], we define

  $$f_{IK}:I^n\to K,$$

  (3)

  as an operator that takes sets of information elements and transforms them into a knowledge element. This is many-to-one: multiple pieces of information can generate one knowledge concept, and one piece of information may contribute to multiple knowledge concepts. For simplicity, one can imagine knowledge elements as summarized patterns, such as a regression model or decision tree derived from multiple data points. Knowledge space K thus has internal structure such as taxonomy, rules, or learned models.
• Wisdom space (W). Let W denote the wisdom space. Wisdom elements $w_{\ell }\in W$ represent evaluative or principle-based conclusions. We can formalize W as containing functions or higher-order predicates that map knowledge to recommended actions or categories of judgment. For instance, a wisdom element might encode a principle like “if knowledge indicates X and the goal is Y, then prefer action Z.” Following the DIKWP view that wisdom is evaluative and purpose-sensitive rather than merely accumulative [14,15,16,18], we define

  $$f_{KW}:K^m\times P^p\to W,$$

  (4)

  meaning that wisdom is derived not only from knowledge but may also be directly influenced by the current purpose P. This reflects that what is wise depends on one’s goals. The mapping $f_{KW}$ may involve logical reasoning, optimization algorithms, or ethical calculus that takes multiple knowledge items and the active purpose to output a wise judgment.
• Purpose space (P). Let P denote the purpose space. Elements $p_q\in P$ are objectives or intents. We can formalize purpose as a state in the system that modulates all other transformations. For example, consistent with purpose-oriented DIKWP modeling and standard decision-theoretic abstraction, P may be represented by a vector of goal priorities or a utility function [14,18,19]

  $$U:\mathrm{outcome}\to \mathbb{R},$$

  (5)

  that the system attempts to maximize. Unique among the dimensions, P is both an input and an output of transformations: some purpose is given, either by designers or by the agent updating its goals, and refined purpose may also be an output. We define an identity or update function for purpose refinement, following the DIKWP claim that purpose can both guide and be updated by higher-order evaluation [14,15,18,19]:

  $$f_{WP}:W^r\times P^s\to P,$$

  (6)
  This function produces refined purpose guidance from wisdom and prior purpose. In a stable scenario, this may simply preserve the top-level goal, whereas in learning or adaptive scenarios it may update goals.

Each of these spaces has an associated content representation. For example, D may consist of numbers, I of symbolic triples, K of graph structures or matrices, W of rules, and P of a vector of goal weights. To make the operationalization explicit,

Table 2. Operational mapping between DIKWP theoretical constructs and prototype implementation components.

DIKWP Layer	Formal Construct	Operational Representation	Architecture/Implementation Component	Example Metadata or Output
Data (D)	Raw content items $d_i\in D$; input subset of ${\mathcal{C}}_t$	Sensor streams, simulation events, logs, raw patient attributes, communication payloads before interpretation	P1/P2 input adapters; ACOS SSL sensor-input service; CARLA/CityFlow/triage streams	Timestamp, source, modality, raw value, integrity flag
Information (I)	Contextualized tuples $i_j=(\mathrm{entity},\mathrm{attribute},\mathrm{value},\mathrm{timestamp})$; $f_{DI}:D\to I$	Parsed events, semantic tags, detected objects, extracted symptoms, state assertions	SSL perception and parsing services; YOLOv3, speech-to-text, intent recognition, DIKWP tagger	Entity label, confidence, provenance, DIKWP dimension, support evidence
Knowledge (K)	Structured concepts $k\in K$; graph nodes and rules; $f_{IK}:I^n\to K$	Knowledge graph nodes/edges, relations, learned state models, clinical or traffic rules	Neo4j knowledge graph, fusion daemon, rule store, shared semantic state in DIKWP-SC	Relation type, causal link, graph update, evidence count, uncertainty score
Wisdom (W)	Evaluative predicates or action-selection functions; $f_{KW}:K^m\times P^p\to W$	Ranked decisions, risk assessments, policy choices, recommended actions under constraints	ACOS CSL; Drools rules; PyTorch RL policy; CWS goal/ethics checks	Decision rationale, risk score, selected action, rejected alternatives
Purpose (P)	Goal or utility state; $U:\mathrm{outcome}\to \mathbb{R}$; $f_{WP}:W^r\times P^s\to P$	Goal vector, priority weights, active constraints, sub-goals, policy memory	ACOS goal state; policy memory; CWD communication policy; CSFS governance constraints	Goal priority, utility estimate, safety constraint, revised sub-goal

maps each theoretical DIKWP layer to its computational representation and to the concrete implementation components used in the prototype.

Transformability across dimensions is characterized by the mappings $f_{DI}$, $f_{IK}$, $f_{KW}$, and $f_{WP}$. Additionally, there may be direct mappings that skip dimensions, which we denote generally, in line with prior DIKWP work on cross-dimensional transformation and uncertainty handling [15,16,18], as

$$f_{XY}:X\to Y,$$

(7)

for any $X,Y\in \{D,I,K,W,P\}$. For instance,

$$f_{DW}:D\to W$$

(8)

would mean that raw data evokes a direct wisdom-like response, analogous to instinct or reflex, without intermediate deliberation. Cross-dimensional mappings are especially important for efficiency; we allow them in the model to capture these phenomena. However, each direct mapping can be conceptually factorized through intermediate layers, even if those layers are bypassed explicitly.

To make these transformations computationally tractable and consistent with graph-based views of cognitive architectures and structured knowledge representation [7,32,54,55], we formalize the content network as a directed graph

$$\mathcal{G}=(\mathcal{C},\mathcal{E}),$$

(9)

where

$$\mathcal{C}=D\cup I\cup K\cup W\cup P$$

(10)

is the set of all content items, and $\mathcal{E}$ is the set of edges representing transformation or derivation relationships. Using standard directed-graph notation for derivation and activation relationships [54,55], for any content $c_x\in X$ and $c_y\in Y$, where X and Y are dimensions, an edge

$$c_x\to c_y\in \mathcal{E}$$

(11)

exists if

$$c_y=f_{XY}\left(S\right)$$

(12)

for some set S containing $c_x$. In simple terms, this graph records which pieces of content led to which other pieces.

Semantic flux, introduced here as an analytic descriptor rather than as an established standardized metric, can then be understood in terms of traversal in this graph. A path in this graph from some data node d to a purpose node p represents a chain of transformations that took a raw input and eventually produced or influenced a goal or decision. We denote by

$$\Pi (c_{\mathrm{in}}\to c_{\mathrm{out}})$$

(13)

the set of all directed paths from a content node $c_{\mathrm{in}}$ to another node $c_{\mathrm{out}}$. For a given time window or cognitive cycle, let ${\mathcal{I}}_{\mathrm{in}}$ denote the set of input content nodes active in that window. Drawing on the DIKWP emphasis on cross-dimensional semantic propagation [15,16,18], we may define flux as

$$\Phi ={\displaystyle \frac{1}{|{\mathcal{I}}_{\mathrm{in}}|}}\sum _{c_{\mathrm{in}}\in {\mathcal{I}}_{\mathrm{in}}}\sum _{c_{\mathrm{out}}\in P}\sum _{\pi \in \Pi (c_{\mathrm{in}}\to c_{\mathrm{out}})}\left|\pi \right|,$$

(14)

essentially averaging path lengths from all inputs to purposes. High values may indicate rich, or possibly convoluted, processing, whereas low values indicate either shallow processing or limited activity.

Content transformability is also concerned with the nature of transformations. We classify transformations as follows:

• Aggregative vs. disaggregative. Does $f_{XY}$ take many inputs to produce one output (aggregative), one input to produce many outputs (disaggregative), or many-to-many?
• Deterministic vs. non-deterministic. Is the transformation a fixed function, or does it involve randomness or learning, such that the same input may yield different outputs at different times?
• Lossy vs. lossless. Does the output preserve all information from the input? Most cognitive transformations are lossy, since summarizing data into information or knowledge discards detail.

Given the DIKWP multidimensional structure, a key property is that more semantically integrated dimensions typically exhibit lower dimensionality but higher semantic content per unit. That is, P may consist of only a few variables, W may be a modest collection of principles, whereas D may be very large. Transformability therefore implies significant dimensionality reduction as we move upward, and potentially expansion as purpose disseminates downward.

Mathematically, one may formalize the content domain of each DIKWP dimension using a sigma-algebra or topological structure so as to enable a measure-theoretic interpretation of information. One may also attempt to define entropy or uncertainty over each dimension. However, given the semantic character of the more abstract DIKWP dimensions, classical entropy may not directly apply beyond the data dimension. Instead, one may introduce semantic entropy or semantic uncertainty for each dimension. For example, in the knowledge dimension, uncertainty may be characterized through properties of the knowledge graph, such as the degree of inconsistency, incompleteness, or the number of unresolved links. Ideally, transformations across DIKWP dimensions should reduce uncertainty or enhance the usefulness of content as processing moves from data-oriented representation toward purpose-oriented organization.

To capture the mesh-like nature of DIKWP, we explicitly allow feedback loops and reciprocal interactions among dimensions. In particular, semantic influence may propagate from more abstract dimensions to more data-proximal ones: the purpose dimension may guide data acquisition and filtering, and the wisdom dimension may influence which knowledge is retrieved, prioritized, or reinterpreted. These downward semantic flows correspond to what cognitive science may describe as top-down attention, modulation, or bias. They ensure that the overall process is not strictly feed-forward, but interactive, adaptive, and dynamic.

In formal terms, let ${\mathcal{C}}_t$ be the content state at time t, that is, all content elements believed or active at time t. The DIKWP process may then be modeled as iteratively updating ${\mathcal{C}}_t$ via the transformations, analogous to recurrent update cycles in cognitive architectures and global-workspace-inspired systems [32,54,55,58]:

$${\mathcal{C}}_{t+1}={\mathcal{C}}_t\cup \left\{f_{XY}\left(S\right):S\subset {\mathcal{C}}_t,X\to Y\mathrm{in}\mathrm{allowed}\mathrm{transforms}\right\}.$$

(15)

This reflects that at each cognitive tick, new content is generated from current content. In practice, implementation may not exhaustively apply all possible transformations, since that could be combinatorially explosive, but instead may follow a controlled cycle similar to a global workspace broadcast or a blackboard system.

The DIKWP model’s formal definitions thus set the stage for algorithmic implementation. In Section 4, while describing the ACOS software, we will effectively specify the algorithms and data structures that realize a subset of these transformations. Before that, however, we incorporate the BUG theory formalism into this picture.

3.2. Formalizing the “BUG” Theory Within DIKWP

To formalize BUG theory in our context, we introduce the notion of a cognitive bug operator and measure its effects on transformations. This formalization draws on the BUG-theory discussion in the DIKWP line of work together with established research on bounded rationality, heuristic decision-making, and the illusion of explanatory depth [23,41,42,43].

We define a bug $\beta$ as a tuple representing transformation-level imperfection

$$\beta =(X,Y,ϵ),$$

(16)

meaning that a transformation from dimension X to dimension Y has an inherent error or omission characterized by parameter $ϵ$. The parameter may represent, for example, the fraction of information lost or the distortion introduced. For simplicity, and in line with scalar error abstractions commonly used in uncertainty-aware modeling [15,42,43], let

$${ϵ}_{XY}\in [0,1]$$

(17)

denote the imperfection rate of transformation $f_{XY}$, where 0 means a perfect transform and 1 indicates a maximally lossy or incorrect transform. In reality, $ϵ$ may be multidimensional, but we treat it as a scalar here.

One approach to incorporating $ϵ$ into the earlier framework is to refine the transformation functions so that they produce not only an output content but also an error estimate or variance, consistent with uncertainty-aware DIKWP modeling and confidence-calibration concerns in modern AI systems [15,44,45]. For example, instead of

$$f_{DI}:D\to I,$$

(18)

we could consider

$$f_{DI}:D\to I\times E,$$

(19)

where E is an error space such as confidence or error metadata. However, tracking error through every transformation is complex and not always well-defined. Instead, we treat bugs as latent properties that accumulate over time.

One possibility, consistent with representing bounded or reconstructed internal content as a transformed version of an intended content state [41,46], is to define a bug function

$$B:\mathcal{C}\to \mathcal{C},$$

(20)

mapping a content element to an alternative content element that the system perceives due to bugs. For example, under the same reconstructed-content abstraction [41,46], for a true knowledge element $k\in K$,

$$B\left(k\right)=k^{\prime },$$

(21)

where $k^{\prime }$ is the system’s possibly flawed representation of k. If the bug is small, then $k^{\prime }\approx k$; if large, $k^{\prime }$ may differ substantially.

Alternatively, we can model bug introduction at each step as noise or systematic deviation, a standard abstraction in uncertain computation and bounded reasoning [42,43]. For a transformation $f_{XY}$, the actual operation under bug influence is

$${\tilde{f}}_{XY}\left(S\right)=f_{XY}\left(S\right)+{\eta }_{XY}\left(S\right),$$

(22)

where ${\eta }_{XY}$ is a noise or deviation term. In some cases, $\eta$ may systematically bias the output rather than acting as purely random noise. For example, a pattern recognizer may consistently undercount a certain type of data.

The BUG theory emphasizes illusions of completeness, which we can formalize as the system not recognizing its own error. This interpretation is consistent with cognitive-science work on overestimated understanding and reconstructive cognition [41,46,47]. In Bayesian terms, the posterior distribution it computes is sharply peaked, while the truth lies outside that peak.

We define a confidence function

$$\mathrm{conf}:\mathcal{C}\to [0,1],$$

(23)

which gives the system’s confidence that a content item is correct. A bug scenario occurs when $\mathrm{conf}\left(c\right)$ is high, but c is wrong or incomplete relative to ground truth or a more informed perspective. One may measure wrongness by distance to truth when truth is known, for example, in simulation. The BUG phenomenon is therefore one in which $\mathrm{conf}\left(c\right)$ is poorly calibrated to actual error. In implementation, a content item is therefore represented not only by its semantic value but also by evidence metadata:

$$c=(v,\dim ,\mathrm{prov},\mathrm{support},\mathrm{conf},ϵ),$$

(24)

where v is the content value, $\dim \in \{D,I,K,W,P\}$ denotes the DIKWP layer, $\mathrm{prov}$ records provenance, $\mathrm{support}$ records the amount or diversity of supporting evidence, $\mathrm{conf}$ records system confidence, and $ϵ$ records the estimated transformation-level imperfection. Here, $\mathrm{support}\left(c\right)$ denotes the support field associated with content item c. When ground truth or external verification is available, a calibration gap can be estimated as

$$\Delta \left(c\right)=\left|\mathrm{conf}\left(c\right)-\mathrm{acc}\left(c\right)\right|,$$

(25)

where $\mathrm{acc}\left(c\right)$ is an externally measured correctness indicator or empirical accuracy estimate. CSFS treats a content item as risky when high confidence is combined with weak support or cross-layer inconsistency. A simplified decision rule is

$$\mathrm{Risk}\left(c\right)={\lambda }_1\left(1-\mathrm{support}\left(c\right)\right)+{\lambda }_2\Delta \left(c\right)+{\lambda }_3\left(1-\mathrm{Cons}(c_x,c_y)\right),$$

(26)

and a security response is triggered when $\mathrm{Risk}\left(c\right)>{\tau }_R$, where ${\lambda }_1,{\lambda }_2,{\lambda }_3$ are implementation-level weights and ${\tau }_R$ is the escalation threshold.

Table 3. Operational role of BUG mechanisms in reasoning and semantic security.

BUG Mechanism	Formal Representation	Influence on Reasoning	CSFS Response
Lossy perception or summarization	Nonzero ${ϵ}_{DI}$ or deviation ${\eta }_{DI}$	May omit weak signals or compress raw inputs into incomplete information, allowing faster perception but risking missed events	Redundant sensor check, provenance tracking, and low-support tagging
Heuristic knowledge formation	Assumption edge or shortcut node in $\mathcal{G}$	May create a plausible knowledge hypothesis before all prerequisites are available	Mark as provisional; request corroboration when the hypothesis affects high-risk action
Bounded wisdom-level reasoning	Approximate ${\tilde{f}}_{KW}$ with bounded search depth or stochastic policy selection	May choose a timely satisficing action rather than a globally optimal action	CWS veto rules and purpose-alignment checks prevent actions that violate safety or governance constraints
Confidence miscalibration	High $\mathrm{conf}\left(c\right)$ with large $\Delta \left(c\right)$ or weak $\mathrm{support}\left(c\right)$	May make partial evidence appear complete, especially under ambiguous or adversarial inputs	Confidence calibration, consistency checking, rollback, or human/policy escalation
Semantic-message propagation	Incorrect K- or W-level content transmitted through DIKWP-SC	May spread an erroneous belief across agents if accepted naively	Trust-weighted consensus, source validation, and cross-agent contradiction detection

summarizes how BUG-induced bounded inaccuracies influence reasoning and security in the proposed architecture.

To incorporate this systematically into DIKWP, one may modify the content update rule to allow acceptance of content that is not fully warranted by evidence. For example, the system may form a knowledge element k from insufficient information because it believes it has enough evidence due to pattern bias. A bug can thus be interpreted as a shortcut activation of a higher-layer element without proper lower-layer support.

If we revisit the content network $\mathcal{G}$, a bug may manifest as an edge or content node that appears without a complete set of prerequisite inputs. This can be modeled by adding assumption nodes or hypothetical edges in the graph. For example, a knowledge node may be added by the system spontaneously as a guessed hypothesis, tagged to indicate that it was not fully derived.

In logic terms, this resembles non-monotonic reasoning or default reasoning: assume something is true until contradicted. This is often how illusions operate—they are accepted until counterevidence accumulates.

From a design perspective for artificial consciousness, we deliberately incorporate bugs by using heuristic algorithms for $f_{XY}$. For example:

• Use a machine learning classifier with known non-zero error rate for $f_{DI}$ instead of a perfect sensor interpretation. This ensures some misinterpretations.
• Use compression techniques for $f_{IK}$ such that not all information is carried upward, thereby introducing lossiness.
• Limit how much knowledge the W dimension can hold simultaneously, forcing it to simplify.
• Use stochastic sampling in the W dimension’s decision-making so that it does not always compute the theoretically optimal move, thereby introducing variability.

Each of these introduces bug-like behavior. Crucially, however, we want beneficial bugs, so we also include mechanisms to detect and mitigate severe bugs. This function is assigned to the DIKWP-CSFS security subsystem. In formal terms, we introduce a consistency check function, following related work on semantic security, controllability, and AI alignment [52,53,66],

$$\mathrm{Cons}:\mathcal{C}\times \mathcal{C}\to \{0,1\}.$$

(27)

For any two related content items, such as data and the corresponding knowledge, we define the binary consistency outputs as a simplified operational abstraction of semantic validation [52,66]

$$\mathrm{Cons}(c_x,c_y)=1$$

(28)

if they are consistent, and 

$$\mathrm{Cons}(c_x,c_y)=0$$

(29)

if they are not. The CSFS subsystem computes checks such as $\mathrm{Cons}(c_x,c_y)$ and, if inconsistency is detected, flags a possible harmful bug or attack. Achieving this requires redundant channels, such as independent ways to estimate the same quantity at different dimensions.

One formal measure is the degree of inconsistency within the content network. If the system believes A and also believes $\neg A$, this represents inconsistency. Some bugs manifest exactly as unnoticed inconsistencies. Techniques from belief revision and inconsistency measurement may therefore be borrowed, for instance by counting contradicting pairs of content in $\mathcal{C}$. The CSFS subsystem aims to minimize such contradictions by resolving them or isolating the faulty content.

Finally, to relate BUG theory back to conscious experience, one may hypothesize that a certain level of bug-induced integration is required for the system to have a non-trivial self-model. A formal exploration of this lies beyond the present scope, but it could involve analyzing fixed points of the content update process in which the system’s output stabilizes despite inaccurate inputs, akin to dreaming or hallucinating in a stable way. Our framework therefore allows the system to generate a hypothesis, process it through DIKWP as if it were real, and later revise it if needed.

3.3. Integrated DIKWP+BUG Model

Combining the above, we now outline how the integrated model operates. The integrated DIKWP+BUG semantic–cognitive model is essentially a DIKWP content network augmented with bug-generation and bug-detection processes. Figure 1 has been redrawn as a high-resolution numbered schematic to connect the visual notation directly with the cognitive-cycle explanation. In the figure, F1 denotes subconscious transformation from data to information and knowledge, F2 denotes wisdom-level deliberation, F3 denotes purpose alignment and feedback, F4 denotes BUG monitoring and CSFS-based semantic security, and F5 denotes learning and memory update.

The numbered notations in Figure 1 correspond to the following cognitive-cycle steps:

F1.

Subconscious processing ($D\to I\to K$). The system collects new data D from sensors or input channels and also carries over some data from the previous cycle as short-term memory. It transforms D to I, imperfectly and with possible misinterpretations, and then aggregates I to update K, possibly compressing and losing details. During this phase, bug introduction is likely in the form of misinterpretation or overgeneralization. The output is a set of knowledge items K representing the system’s understanding of what is going on.

F2.

Conscious deliberation ($K\to W$). Given the knowledge base and the current purposes, the system formulates wisdom-level judgments. It may simulate various outcomes, check constraints, and incorporate guiding principles. Here, bug introduction may manifest as flawed reasoning shortcuts, such as ignoring a low-probability outcome or using an imperfect analogy. The result is one or more wisdom elements W, such as a recommended decision or a prediction of what will happen next.

F3.

Purpose alignment ($W\to P$ and update). The wisdom is then used to update or confirm the current actions corresponding to purpose. The system effectively asks: “Given what I conclude, what should I do or aim for next?” If the existing purpose fully covers the situation, the system may simply output an intention. Otherwise, it may refine the purpose by adding a sub-goal or adjusting priorities. These outputs can also be treated as data for the next cycle, forming a feedback loop.

F4.

BUG monitoring and semantic security. Concurrently with the above steps, the system runs consistency checks and monitors anomalies. For every critical transformation, especially those susceptible to bugs, there is a validation process. For example, if $f_{DI}$ identifies an object as a human with high confidence, the system may cross-check using another method or sensor. If a large inconsistency is found, such as knowledge asserting both X and $\neg X$, the system flags it. Depending on severity, it may revise beliefs, query for more data, or alert a human operator. Minor bugs that do not cause significant inconsistencies are allowed to persist, as these are the illusions that can facilitate efficient cognition. Harmful bugs that create contradictions or conflict with core purposes are treated as security issues and trigger defensive measures.

F5.

Learning and memory update. Over longer timescales, the system learns from experience. BUG theory suggests that memory is reconstructed rather than stored as a perfect log. Accordingly, when consolidating knowledge into long-term memory, the system may compress episodes into narrative form, possibly introducing hindsight bias or other distortions. It stores not exactly what happened, but what it judges to have been important. Future decisions then draw on this compressed and possibly distorted memory, which is analogous to human memory.

By integrating bugs, the system does risk forming false beliefs. This is why the security net is crucial: it acts like a subconscious error-correcting reflex.

We hypothesize that an artificial consciousness system with this integrated approach will display more robust and context-appropriate behavior than one without it. For instance, if data are noisy or conflicting, a non-BUG system may stall or erratically switch hypotheses, whereas a BUG-enabled system may prematurely settle on one hypothesis and proceed smoothly. Although this hypothesis may later prove incorrect, the security layer or subsequent evidence can correct it. In complex environments, such behavior may be preferable to waiting indefinitely for perfect certainty.

In formal evaluation, we may measure understanding resilience, namely the system’s ability to maintain purposeful operation under imperfect information. A BUG-integrated system should achieve higher understanding resilience, defined for example as successful task completion rate in environments with high uncertainty or adversarial disturbance, compared with a purely rational but brittle system.

To summarize the theoretical framework, we have defined the DIKWP dimensions, the transformation functions with allowances for multiple paths and cycles, and parameters that account for cognitive bugs in these transformations. We have also defined the conceptual role of the security subsystem in maintaining overall coherence. This framework lays the groundwork for the system architecture, where these abstract functions are mapped to concrete components such as hardware modules, operating system processes, and communication protocols.

In the next section, we present the architecture design, showing how each part of the DIKWP+BUG model is implemented in the artificial consciousness ecosystem.

4. System Architecture Design and Module Specifications

Building on the above theoretical model, we propose a full-stack system architecture for an artificial consciousness computing ecosystem. Figure 2 has been redrawn with explicit module notations so that the visual structure can be read together with the subsection organization. The architecture contains four major components: A1 ACPU—Artificial Consciousness Processing Unit, A2 ACOS—Artificial Consciousness Operating System, A3 DIKWP-SC—Semantic Communication Subsystem, and A4 DIKWP-CSFS—Concept–Semantic Fused Security Subsystem. These components collectively realize the DIKWP+BUG framework in a distributed, high-performance, and secure manner. The design principle is to achieve unified hardware–software integration for cognitive processing, semantic communication, and active security protection spanning all five DIKWP dimensions (D, I, K, W, P).

4.1. Overview of the Full-Stack AC Ecosystem Architecture

At a high level, the architecture can be viewed as a layered stack with feedback loops:

A1.

ACPU hardware layer.

The ACPU provides the computational substrate, divided internally into specialized units for subconscious processing over D, I, and K, and conscious processing over W and P. It also includes interfaces for real-time semantic I/O and built-in security enforcement at the hardware level.

A2.

ACOS software layer.

ACOS runs on the ACPU and manages cognitive processes, short-term and long-term memory, scheduling of subconscious versus conscious tasks, and APIs for communication and security modules. ACOS implements the DIKWP cognitive cycle in software by coordinating transformation flows across the layers.

A3.

DIKWP-SC semantic communication layer.

DIKWP-SC connects the AC unit with external agents, conventional systems, and human interfaces. Unlike standard networks that transmit raw data or predefined messages, DIKWP-SC routes messages according to semantic content and DIKWP dimension, enabling knowledge- or wisdom-level exchange and low-latency coordination.

A4.

DIKWP-CSFS security layer.

DIKWP-CSFS is interwoven across hardware, OS, and communication layers. It monitors both cybersecurity risks and cognitive-security risks, including data tampering, semantic inconsistency, dangerous BUG propagation, goal conflict, and unsafe high-level reasoning. It fuses low-level and high-level detections to enact real-time protective measures.

These components are deeply integrated rather than siloed. The ACPU and ACOS have a symbiotic relationship: hardware actively supports the software’s cognitive processes, and software continuously optimizes hardware operation. Similarly, the communication and security subsystems are not standalone services but are embedded into the cognitive workflow. For example, each time ACOS prepares knowledge to send out, it uses DIKWP-SC formatted messages and passes them through CSFS checks.

The architecture can also be viewed in terms of spaces or layers of operation:

S1.

Subconscious space.

This space encompasses the Data, Information, and Knowledge dimensions and their processing modules in ACPU/ACOS. It is responsible for perception, pattern recognition, and routine responses.

S2.

Conscious space.

This space encompasses the Wisdom and Purpose dimensions and their processing modules. It is responsible for reasoning, planning, and goal management.

S3.

Communication space.

This space is the semantic network connecting this AC system to other agents and human interfaces. It enables collective intelligence and multi-agent coordination through shared semantics.

S4.

Security space.

This space consists of monitoring and intervention signals that overlap the other spaces to ensure integrity, semantic consistency, and purpose alignment.

This partitioning is broadly consistent with the “Four Spaces Framework” comprising the conceptual, semantic, cognitive, and conscious spaces. However, the present study places greater emphasis on its architectural realization through the interaction between subconscious and conscious processing, together with the associated supporting subsystems.

Table 4. Mapping from formal DIKWP+BUG operators to architecture modules.

Formal Element	Architectural Realization	Implementation Mechanism	Runtime Role
$f_{DI}:D\to I$	A2.1 SSL with A1.1 subliminal fabric	Sensor parsing, object detection, speech/intent recognition, input adapters	Converts raw streams into semantic events and information tuples
$f_{IK}:I^n\to K$	SSL knowledge-fusion daemon and knowledge memory	Neo4j graph update, relation extraction, rule insertion, semantic aggregation	Stabilizes information into reusable knowledge structures
$f_{KW}:K^m\times P^p\to W$	A2.3 CSL with A1.2 conscious fabric	Drools rules, reinforcement-learning policy, scenario evaluation, constraint checking	Produces risk rankings, decisions, and recommended actions
$f_{WP}:W^r\times P^s\to P$	Goal state, policy memory, and CWD policy engine	Goal-priority update, communication policy selection, action–goal refinement	Aligns decisions with purpose and updates sub-goals
${\tilde{f}}_{XY}=f_{XY}+{\eta }_{XY}$	BUG-aware processing across SSL, SCFL, CSL, and DIKWP-SC	Lossy compression, bounded search, provisional assumptions, confidence metadata	Enables timely approximate cognition while exposing imperfection metadata
$\mathrm{Cons}(c_x,c_y)$	A4 DIKWP-CSFS and CWS/SCFS monitors	Threshold checks, one-class SVM, Drools veto rules, cross-agent corroboration	Detects harmful bugs, attacks, and semantic contradictions

further summarizes the explicit mapping from the formal operators introduced in Section 3 to the architectural modules.

In the following subsections, we detail each major component of the architecture, including internal submodules, their mappings to the theoretical constructs (DIKWP dimensions, transformations, bug handling), and their interactions. We also include pseudo-workflows to illustrate the sequence of operations in typical scenarios.

4.2. ACPU (Hardware Layer)

The ACPU is a specialized hardware unit optimized for the DIKWP cognitive model. It can be viewed as a hybrid processor that combines the massively parallel data-processing capabilities of modern AI accelerators with the symbolic reasoning support of traditional CPUs, along with additional circuits for semantic interfacing and security.

4.2.1. Internal Architecture of ACPU

Based on the DIKWP division, ACPU consists of three primary hardware modules:

(a)

Subliminal Space Hardware Module. This corresponds to subconscious processing (D, I, and K dimensions). It includes GPU-enhanced tensor cores and transformer neural network accelerators for heavy AI computation. This module is suited to tasks such as signal processing, neural network inference, and graph processing for knowledge graphs. It operates analogously to the human brain’s sensory and pattern-recognition areas. By incorporating Transformer and Graph Neural Network (GNN) hardware, it natively supports deep learning and relational reasoning tasks on-chip, which are essential for implementing $f_{DI}$ and $f_{IK}$. The design may resemble current GPU/TPU systems but extended with semantic tagging, such that each computed result can carry a tag indicating the relevant DIKWP dimension or concept.

(b)

Consciousness Space Hardware Module. This hardware is tailored for abstract, sequential, or symbolic processing, aligning with the W and P dimensions. It may be seen as a CPU-like decision module, possibly multi-core, focusing on complex logic, or incorporating neuromorphic elements for spiking neural networks that simulate attention. It may also integrate FPGA or ASIC blocks implementing logic inference or constraint-solving algorithms. This module takes outputs from the knowledge dimension and performs wisdom-level computation such as scenario simulation, logical reasoning, planning algorithms (e.g., $A^{*}$ search or linear programming), and goal arbitration. It is also explicitly aware of the BUG aspect: it may include approximate computing circuits that deliberately trade accuracy for speed, thereby introducing bounded imperfection by design. It interfaces with special registers that represent Purpose, where current goal parameters influence computation.

(c)

Real-time Semantic Fusion Interface and Security Engine. This module serves as both integration fabric and guardian. It provides high-bandwidth channels (e.g., NVLink, PCIe 5.0, or an on-chip bus) between the subliminal and conscious modules so that they can exchange data with minimal latency. It also connects the ACPU to external communication interfaces and sensor inputs. As data arrives, the interface may perform preprocessing such as encryption/decryption, packetization with semantic labels, or filtering of irrelevant data before the information reaches the main processors. Hardware-level security is also enforced here, including memory isolation, execution of security protocols, and anomaly monitoring. Components may include a hardware firewall, a random number generator for cryptographic needs, and a monitor core running diagnostic firmware separate from the main OS. This interface is designed to preserve real-time performance while providing a hardware root of trust.

In summary, the ACPU can be understood as a brain-inspired SoC in which the “lower brain” (subliminal module) handles parallel sensory and subconscious tasks, the “higher brain” (conscious module) performs focused reasoning, and the semantic fusion interface links everything together while ensuring secure interaction with the outside world.

4.2.2. Key Features and Design Strategies in ACPU

• Memory architecture. The memory system is likely heterogeneous, with one part being small and high-speed for conscious reasoning (analogous to working memory) and another part being large and slower for long-term knowledge storage. Technologies such as stacked DRAM or MRAM may be used for fast access to critical knowledge, while flash or off-chip memory may hold large data archives. The memory is unified in address space but managed so that different DIKWP dimensions mostly reside in specific regions.
• Parallel versus serial balance. Subliminal tasks such as deep learning inference run massively in parallel on tensor cores, whereas conscious tasks may be more single-thread intensive. The ACPU dynamically allocates power and clocking to these parts as needed.
• Support for DIKWP operations. The processor may introduce instruction-set extensions that directly support DIKWP operations. Examples include instructions to “promote data to information” or to “merge knowledge nodes,” analogous to how AI accelerators introduced instructions for matrix multiplication.
• Energy considerations. Since AC systems may run continuously under large workloads, power management is essential. The ACPU may incorporate neuromorphic or analog components, especially for subconscious processing, to reduce energy use. Purpose-aware control can also allow nonessential processing to be degraded when energy is low.

4.2.3. ACPU’s Role in DIKWP+BUG

The hardware directly ensures that certain bug-like phenomena, or their detection, are ingrained in system operation. For instance, analog or low-precision computation in the subliminal module can introduce small errors, whereas the conscious module may run at higher precision or double-check critical results. The hardware security engine may even inject tiny perturbations into redundant computations as a stress test for robustness. Because the ACPU is dedicated to artificial consciousness workloads, it can be tested and tuned using known conscious-task patterns, unlike general-purpose CPUs.

Through the close coupling of ACPU and ACOS, discussed next, the architecture aims to support software–hardware co-optimization for efficiency and robustness. The prototype results reported in Section 6 are consistent with the potential benefits of such specialization, although the present study evaluates a runtime emulation rather than a fabricated custom processor.

4.3. ACOS (Software Layer)

ACOS is the software core that runs on the ACPU and implements DIKWP cognitive processes through system-level services. It may be viewed as an operating system in the sense that it manages resources and processes, but it is highly specialized for cognitive tasks.

4.3.1. Design Principles

ACOS is designed to be real-time, modular, and semantic-aware. Real-time means that it can guarantee responses within required deadlines, which is critical in scenarios such as autonomous driving. Modular means that each DIKWP dimension has corresponding modules that can be updated or replaced. Semantic-aware means that the OS recognizes that processes carry semantic tags, such as “this process is handling Knowledge-dimension integration,” and can schedule or prioritize accordingly.

4.3.2. Major Software Modules of ACOS

According to the architecture, ACOS includes at least three major modules:

(a)

Subliminal Space Management Module (SSL). This module handles data, information, and knowledge processing in software. It includes device drivers for sensors, data fusion and filtering routines, information extraction pipelines, and a knowledge-base management system. The knowledge base may combine a relational database, a graph database, and a neural knowledge network. SSL is also responsible for short-term memory and intermediate caches. Most BUGs naturally arise here because heuristic algorithms dominate this layer. ACOS does not seek to eliminate all such quirks, but rather to monitor them. For example, the module may record confidence levels for each inferred information item and indicate whether a result was inferred from weak evidence. In implementation, SSL may be realized as multiple microservices, such as a vision service, an audio-processing service, and a world-model integration service.

(b)

Conscious Intelligence Decision-Making Module (CSL). This module corresponds to W-dimension processing and part of P-dimension processing. It serves as the executive reasoning component and may operate as a privileged service because it guides the overall system behavior. CSL integrates inputs from the knowledge base and the current goal state to perform higher-level reasoning, including deliberative planning for goal-directed action sequence generation, decision-making under uncertainty, conflict resolution when knowledge items or goals are inconsistent, ethical or legal reasoning where applicable, and self-modeling, such as updating beliefs about battery state or available capabilities. The CSL determines the system’s next intended action or conscious response. It may not run continuously at full intensity but instead be triggered by significant knowledge events or timing conditions. The BUG aspect also appears here: for the sake of speed, CSL may employ approximate reasoning, such as bounded search depth or heuristic evaluation, and may therefore produce a satisfactory rather than globally optimal action. ACOS may accordingly expose tunable parameters governing how much time CSL spends deliberating before acting under uncertainty.

(c)

Subconscious–Conscious Fusion Interaction Module (SCFL). This module mediates between SSL and CSL. It manages the upward flow of information and knowledge as well as the downward flow of commands, goals, and focus directives. Specifically, its responsibilities include attention allocation, namely deciding which subset of knowledge or information should be brought to conscious attention at a given time; broadcasting conscious decisions, that is, propagating CSL outputs to all relevant subconscious processes; synchronization, namely ensuring that CSL reads a coherent snapshot of the knowledge base; and interruption handling, namely allowing urgent sensor events to preempt ongoing conscious deliberation. SCFL therefore embodies a global-workspace-like function. At the implementation level, it may rely on shared memory or message queues and may follow a publish-subscribe design.

4.3.3. Additional Operating-System Services

Beyond the core cognitive modules, ACOS contains standard OS services tailored for artificial consciousness:

• Memory Manager: allocates and garbage-collects memory for short-term information versus long-term knowledge.
• Process Scheduler: ensures that time-critical tasks such as sensor reading and safety checks receive high priority, while also allowing Purpose to influence scheduling decisions.
• Device Drivers and HAL: bridge the hardware specifics of ACPU to the OS, including access to tensor cores, neural accelerators, and semantic networking hardware.

4.3.4. ACOS and DIKWP Integration

Each DIKWP dimension corresponds to specific data structures and processes inside ACOS:

• Data and Information: represented by sensor buffers and event lists and processed by dedicated threads.
• Knowledge: represented by an efficient knowledge base, such as an in-memory graph structure, triple store, or differentiable neural memory.
• Wisdom and Purpose: represented through explicit structures such as an agenda of pending decisions, active constraints, or an internal goal stack.

4.3.5. Fault Tolerance and BUG Handling in ACOS

Because ACOS sits above the hardware layer, it can implement higher-level bug mitigation strategies:

• Redundant reasoning: running multiple algorithms for critical decisions and comparing their outputs;
• Checkpoints: maintaining previous stable states so that contradictions can trigger rollback;
• Introspection: background processes analyze logs to identify cognitive components that systematically produce errors;
• Parameter adjustment: the system can self-tune attention aggressiveness, deliberation depth, and similar parameters based on past performance, effectively adjusting BUG-related behavior such as $ϵ$.

ACOS must also interface closely with communication and security subsystems. It provides API hooks through which security components may freeze processes or inspect memory, and through which communication modules may serialize and deserialize semantic structures. In essence, ACOS is the consciousness kernel: it operationalizes the DIKWP model by orchestrating the flow from data to purpose while leveraging specialized hardware and maintaining overall stability.

4.4. DIKWP-SC: Semantic Communication Subsystem

The DIKWP-SC enables the AC system to communicate with other systems or human users in a content-rich and goal-aware manner. Traditional protocols operate at the level of bytes and packets without understanding their meaning. By contrast, DIKWP-SC works with messages carrying semantic labels corresponding to DIKWP dimensions. This is grounded in the broader concept of semantic communication, which aims to transmit the meaning of messages rather than only raw bits.

4.4.1. Architecture of DIKWP-SC

It comprises three main modules:

(a)

Subliminal Semantic Communication Module (SSP). This module handles low-level, high-speed data transport while maintaining awareness of semantic segmentation. It extends physical- and data-link-layer functions by packetizing data with semantic labels and assigning differentiated QoS levels or communication channels to distinct content types. It also performs layer-appropriate encoding and compression. For instance, data-dimension content may adopt lossy compression, whereas knowledge dimension content may rely on stronger error-correction mechanisms to preserve exact symbolic meaning. SSP operates largely below the system’s conscious level and is primarily concerned with communication efficiency and transport reliability.

(b)

Consciousness-level Communication Decision Module (CWD). This module serves as the high-level control component for communication. It determines what should be communicated, when communication should occur, with whom communication should be established, and which modality should be used. In multi-agent scenarios, it may determine that one agent should periodically share knowledge summaries while transmitting raw data only on demand. In human-interaction settings, it may translate internal knowledge representations into natural-language explanations. CWD can further support semantic handshakes for establishing shared ontologies or mappings prior to information exchange, bandwidth and relevance management for selecting which content is worth transmitting under limited communication resources, and privacy and policy enforcement for determining whether information may be shared under purpose and security constraints.

(c)

Semantic-Intelligent Converged Communication Module (SFM). This module integrates SSP and CWD and manages the end-to-end communication process. It supports multiple modalities within a unified communication channel and is responsible for integrating outgoing messages from different layers into a coherent transmission stream, ensuring synchronization between communicating systems, adapting to changing network conditions, and applying advanced semantic-aware encoding strategies where appropriate.

DIKWP-SC is likely implemented as middleware inside ACOS or closely tied to the OS networking stack. It may rely on existing physical-layer technologies while overlaying a custom semantic protocol such as a DIKWP-aware application layer.

4.4.2. Collaboration and Multi-Agent Considerations

In scenarios such as smart-city coordination or swarms of vehicles, DIKWP-SC enables a form of collective artificial consciousness. Nodes can share parts of their DIKWP state, especially knowledge and purpose information, so that understanding is formed once and then distributed, rather than repeatedly inferred from raw data at every node. This reduces redundant effort and increases consistency.

4.4.3. Real-Time Semantic Communication

A central challenge is preventing communication from becoming a bottleneck. We address this through high-speed interconnects, communication coprocessors where needed, and semantic compression that reduces message size by sending meaningful summaries instead of raw streams. For example, sending the knowledge item “accident ahead at street X” is much more efficient than streaming video and requiring every receiver to infer that conclusion independently.

4.4.4. Handling BUGs over Communication

Communication can itself introduce or propagate bugs. If one agent forms incorrect knowledge and transmits it, the error may spread. DIKWP-SC, together with CSFS, addresses this by attaching confidence levels, optionally transmitting supporting evidence, and enabling trust-weighted consensus across agents. Because messages are semantic, it becomes easier to run consistency checks. If one agent claims that a bridge has collapsed while another reports having just crossed it safely, the contradiction is immediately visible at the knowledge level.

In summary, DIKWP-SC transforms the communication layer from a passive transport channel into an active facilitator of collective intelligence. It ensures that the AC system is not an isolated intelligence, but part of a wider network of machines and humans capable of sharing understanding in support of broader goals.

4.5. DIKWP-CSFS: Concept-Semantic Fused Security System

The DIKWP-CSFS subsystem is an integrated security framework operating across conceptual understanding and low-level data handling. It combines semantic security, which ensures that meanings and decisions remain safe and aligned, with traditional cybersecurity, which protects against attacks and faults at the data, software, and hardware levels. This dual approach is necessary because an artificial consciousness system can be compromised not only by conventional cyber attacks but also by deception, manipulation, and semantically misleading inputs.

4.5.1. Components of DIKWP-CSFS

The subsystem includes three major modules:

(a)

Subliminal Semantic Security Module (SSS). This module safeguards subconscious-layer activities associated with the Data, Information, and Knowledge dimensions. Its primary functions include sensor and data security, namely monitoring raw inputs for tampering, spoofing, or implausible values; information consistency checking, namely determining whether newly extracted information conflicts with established knowledge without sufficient explanation; knowledge-base integrity protection, namely preventing unauthorized or unexplained modification of stored knowledge; and load monitoring, namely identifying resource-exhaustion attacks or overload conditions and throttling lower-priority inputs when necessary.

(b)

Awareness Smart Security Module (CWS). This module corresponds to conscious-level security and alignment management. Its main functions include goal alignment, namely ensuring that Purpose remains consistent with externally imposed constraints and ethical rules; self-consistency and sanity checking, namely monitoring wisdom- and purpose-level reasoning for contradictions or irrational states; social and communication ethics control, namely preventing inappropriate disclosure, unauthorized commitments, or invalid external interactions; and cognitive security reflexes, namely triggering defensive responses when manipulation attempts or unsafe requests are detected.

(c)

Semantic-Intelligent Real-Time Security Fusion Module (SCFS). This module integrates signals from SSS and CWS and performs real-time monitoring of the entire system. Its main functions include event correlation, namely linking low-level anomalies to high-level decision irregularities; unified threat response, namely placing the system into safe states, issuing alerts, or restricting operation under serious threats; security policy enforcement, namely applying system-wide safety and governance rules; active threat learning, namely adapting detection strategies based on newly observed attacks or failure modes; and communication with external security authorities, namely transmitting alerts or receiving external threat intelligence where applicable.

The fusion of concept-level and semantic-level security is a central feature. Traditional security systems may detect malicious code or suspicious packets, but they do not understand meaning. Conversely, a purely ethical reasoning module may fail to detect that its perceptual inputs have been corrupted. CSFS addresses both problems simultaneously.

4.5.2. Integration with ACOS and ACPU

The security modules are tightly integrated with both hardware and software:

• SSS uses ACPU features such as memory protection and secure enclaves and uses ACOS hooks to quarantine processes or isolate suspicious data flows.
• CWS is implemented through high-level algorithms such as rule evaluators or consistency checkers running under ACOS supervision.
• SCFS may be split across hardware and software so that rapid shutdown or isolation actions can occur at hardware speed while higher-level assessment remains available in ACOS.

For performance reasons, security checks are designed to run in parallel with ordinary cognitive processing whenever possible. Sensor validation happens as data arrive, and ethical or goal-alignment checks are embedded into decision branches rather than appended only at the end. In the reported simulation settings, the integrated security design was associated with fewer safety incidents and faster anomaly mitigation than baseline configurations in which security was treated more peripherally.

4.5.3. Resilience Through CSFS

CSFS also supports resilience against accidental faults in addition to adversarial attacks. If a memory bit flips and corrupts knowledge, or if a hardware component emits out-of-spec signals, inconsistency detection and anomaly monitoring can identify the problem before it propagates into dangerous decisions. This is particularly important in distributed applications such as smart-city governance, where a single faulty subsystem should not trigger a system-wide error.

In conclusion, DIKWP-CSFS ensures that the AC system is both self-protecting and self-correcting. It provides the trust layer needed for deploying such systems in real-world, high-stakes environments.

4.6. Overall Operational Workflow and Interaction of Modules

Having described the individual components, it is useful to illustrate how they work together during a typical operation cycle of the artificial consciousness system. Below we outline a representative cognitive cycle and highlight module interactions.

1.

Perception and subconscious processing. Raw data streams from sensors or network inputs enter through the ACPU interface. The subliminal hardware accelerates initial processing such as object detection, parsing, and feature extraction, feeding results into ACOS’s SSL module. Data are transformed into information and then inserted into short-term memory and knowledge structures. During this stage, the SSS security component checks input authenticity and plausibility.

2.

Attention and fusion. The SCFL module monitors newly generated knowledge and decides which items deserve conscious attention. For example, an obstacle detected ahead of a vehicle is highly relevant to the current purpose of safe driving. SCFL may also fuse evidence from multiple sensors, while SCFS may cross-check inter-sensor consistency.

3.

Conscious reasoning and decision. Relevant knowledge is passed to CSL together with the current Purpose state. CSL performs wisdom-level reasoning, such as weighing options, simulating outcomes, and checking constraints through CWS. The result may be a decision such as “brake immediately,” which becomes a Wisdom-dimension conclusion and updates Purpose into a concrete action goal.

4.

Action execution. SCFL disseminates the conscious decision to the relevant subconscious modules or actuator controllers. In the vehicle example, motion control receives a braking command. At the same time, DIKWP-SC may send knowledge-level messages to nearby agents, such as a warning that braking is underway because of an obstacle.

5.

Feedback and learning. The action changes subsequent sensory data, and the cycle continues. Over longer time scales, the system may also learn from experience, adjusting parameters if it finds that bugs or simplifications previously caused near-failures or degraded performance.

6.

Multi-agent interaction. In larger deployments, DIKWP-SC allows one agent’s knowledge to become part of another agent’s knowledge without requiring redundant perception. Higher-level Purpose alignment can also be broadcast across multiple units.

7.

Security interventions. If malicious, inconsistent, or dangerous conditions are detected at any point, CSFS coordinates the response. This may include rejecting invalid commands, switching to backup sensing, quarantining data sources, or escalating to human supervision.

This integrated operation demonstrates the collaborative mechanism of hardware, software, communication, and security described above. Specifically:

• the ACPU hardware actively supports ACOS’s timing and computation needs;
• ACOS software dynamically optimizes hardware usage according to context and purpose;
• semantic communication is integrated seamlessly with decision-making;
• the security system actively monitors and intervenes without undermining core functionality.

Across repeated cognitive cycles, the AC system continuously updates its understanding, pursues its goals, and maintains self-checks and adaptation. The main architectural advantage is that hardware, software, networking, and security are all organized around a shared DIKWP semantic framework. By designing the system in this manner, we aim to provide a coherent platform for exploring purpose-aware semantic architectures. In the following section, the prototype is evaluated through controlled simulations in several scenarios to examine efficiency, decision quality, and security-related behavior under the tested conditions.

5. Implementation and Simulation Environment

To evaluate the proposed architecture, we developed a prototype runtime realization together with a multi-scenario simulation testbed. The present implementation should be understood as an emulation of the proposed ACPU/ACOS ecosystem using available hardware and software components, rather than as a finalized custom-chip or production operating-system deployment. Figure 3 has been redrawn with a clearer runtime flow and compact notations. In the figure, P1 denotes the simulation environments, P2 denotes input adapters and semantic tagging, P3 denotes ACOS runtime services, P4 denotes hardware emulation, P5 denotes DIKWP-SC inter-agent communication, P6 denotes CSFS monitoring and recovery, and P7 denotes logging and metric collection. The principal implementation, simulation, and evaluation settings are described below and summarized later in this section.

To improve reproducibility,

Table 5. Prototype stack, data pipeline, and communication details.

Component	Prototype Realization	Reproducibility-Relevant Detail
Compute substrate	Multi-GPU CUDA server for subliminal processing; pinned CPU core for conscious processing; CUDA 11.8 unified memory and high-speed GPU–CPU interconnect; FPGA-based network cards for semantic I/O and monitoring	Used to emulate A1 ACPU partitioning; product-specific device identifiers and driver versions are recorded with the reproducibility metadata available upon reasonable request
Operating environment	Ubuntu Linux 22.04 LTS with Docker 24.0 services	Each cognitive service runs as an isolated container or process; service logs include start time, cycle ID, resource usage, and emitted DIKWP events
Data-processing pipeline	Simulation stream → input adapter → SSL parsing/perception → SCFL fusion → knowledge graph update → CSL decision → action or semantic message	The pipeline records source, timestamp, DIKWP dimension, confidence, provenance, and action outcome for each critical event
Model and reasoning modules	YOLOv3 vision, speech-to-text and intent recognition, Neo4j 5.14 graph database, Drools 7.73.0.Final rules, PyTorch 2.1.2 reinforcement-learning policy, GPT-2 diagnostic component in the medical scenario	Online evaluation uses initialized or pretrained components; offline preparation costs are reported separately from online latency
Communication protocol	JSON DIKWP-SC messages with source, target, dimension, content, optional confidence/provenance fields; TLS 1.3 encryption; zstd 1.5.5 compression; UDP/TCP and UDP multicast for timing-critical exchange	Hazards above confidence 0.8 are broadcast; events below 0.5 trigger corroboration requests rather than immediate broadcast
Security and recovery	Linux Security Modules, threshold rules, scikit-learn 1.3.2 one-class SVM detectors, Drools 7.73.0.Final veto rules, heartbeat monitoring, restart/corroboration/safe-fallback logic	Alerts are linked to content IDs and can trigger quarantine, corroboration, safe fallback, or human/policy escalation

separates the hardware-emulation substrate, software services, data-processing pipeline, communication protocol, and monitoring components used in the prototype. The values should be interpreted as the configuration of the reported runtime emulation rather than as a fabricated ACPU specification.

To address reproducibility of the implementation environment,

Table 6. Software, middleware, simulator, and model-library versions used in the runtime emulation.

Software/Library/Model	Version Used	Role in the Prototype
Ubuntu Linux	22.04 LTS; Linux kernel 5.15	Host operating environment and Linux Security Modules support
Docker	24.0	Containerization and isolation of ACOS runtime services
Python	3.10.12	Middleware, simulation adapters, SCFS coordinator, logging, and analysis scripts
C++/compiler toolchain	C++17; GCC 11.4	Low-level monitoring hooks and performance-critical runtime components
OpenJDK/JNI	OpenJDK 17	Java interface for invoking Drools rule services from the Python/C++ runtime
CUDA/cuDNN	CUDA 11.8; cuDNN 8.9	GPU acceleration and emulation of the subliminal processing substrate
PyTorch	2.1.2	Reinforcement-learning policy and neural-model inference
scikit-learn	1.3.2	One-class SVM anomaly detection in the SSS/SCFS pipeline
YOLOv3	Darknet-53 YOLOv3, COCO-pretrained weights	Vision object-detection component in SSL perception
Hugging Face Transformers/GPT-2	Transformers 4.36.2; GPT-2 small checkpoint	Medical-language reasoning component in the triage simulation
Neo4j	5.14	Knowledge graph storage and update service
Drools	7.73.0.Final	Rule engine for decision rules, ethical constraints, and veto rules
Redis	7.0.15	Publish/subscribe messaging and shared-memory-style coordination between SSL, SCFL, and CSL
CityFlow	0.1	Smart-city traffic simulation baseline and governance extensions
CARLA	0.9.14	Autonomous-driving and IoV simulation environment
zstd	1.5.5	Compression of DIKWP-SC semantic messages
OpenSSL/TLS	OpenSSL 3.0; TLS 1.3	Encryption layer for DIKWP-SC communication

lists the principal software, middleware, simulator, and model-library versions used in the runtime emulation. Protocols without software version identifiers, such as JSON, TCP/UDP, and UDP multicast, are reported by protocol name.

5.1. Prototype Implementation of Core Components

5.1.1. Hardware Emulation

Because a full custom ACPU chip is beyond the current scope, we emulated its main functions with high-end computing hardware. A multi-GPU server represented the subliminal hardware module, with GPUs handling parallel data processing, and a dedicated pinned CPU core represented the consciousness module. GPU–CPU interaction was approximated with CUDA unified memory and a high-speed interconnect comparable to NVLink, yielding transfer latency on the order of a few microseconds in the prototype platform. We also used FPGA-based network cards to emulate specialized communication and security processors: one FPGA core handled semantic packet tagging and encryption for DIKWP-SC acceleration, and another monitored traffic and memory patterns to emulate hardware-level SSS/SCFS supervision.

5.1.2. ACOS Software

ACOS was implemented as a set of Python 3.10.12 and C++17 services on Ubuntu Linux 22.04 LTS and containerized with Docker 24.0 to simulate module isolation. The SSL comprised a sensor-input service for logged or real-time streams, YOLOv3-based object detection for vision, a speech-to-text and intent-recognition model for language inputs, and a Neo4j 5.14-backed knowledge graph with custom schemas. A knowledge-fusion daemon listened to the outputs of these AI models and updated the graph, thereby supporting Information-to-Knowledge integration. The CSL was implemented as a Python 3.10.12/C++17 hybrid: Drools 7.73.0.Final, invoked through JNI on OpenJDK 17, encoded high-level decision rules and ethical constraints, while a PyTorch 2.1.2-based deep reinforcement-learning agent handled continuous decision optimization. The SCFL interaction layer used Redis 7.0.15 pub/sub together with shared memory, so that knowledge updates and action decisions could propagate between the SSL and CSL with low overhead.

5.1.3. Semantic Communication

DIKWP-SC was implemented on a virtual local network connecting multiple Docker containers, each representing an AC agent. We used a JSON-based semantic message format with the fields source, target, dimension, and content. A custom Python 3.10.12 middleware intercepted socket calls, serialized messages, applied TLS 1.3 encryption through OpenSSL 3.0 and zstd 1.5.5 compression, and transmitted them via UDP or TCP. On the receiving side, the middleware deserialized the message and routed it to the appropriate module, for example by updating the receiving agent’s knowledge graph or forwarding a data-level payload to a sensor buffer. Timing-critical exchanges, such as vehicle platooning or conflict avoidance, were simulated with UDP multicast to minimize latency. CWD policies were represented by a confidence-based policy engine: hazards detected above a threshold of 0.8 were broadcast to nearby agents, whereas events below 0.5 triggered corroboration requests rather than immediate broadcast.

5.1.4. Security Subsystem

The SSS combined operating-system protections with custom anomaly monitors. Linux Security Modules were used for process isolation and file-access control, while C++ hooks monitored sensor streams through both threshold rules and scikit-learn 1.3.2 one-class SVM detectors to flag out-of-distribution readings. For CWS, we encoded allowed and disallowed action rules in Drools 7.73.0.Final as high-priority veto rules; examples included blocking a red-light crossing when emergency=false and flagging directives that contradicted constitutional constraints. We also implemented heartbeat monitoring: if the conscious process became unresponsive or deviated from normal resource usage, SCFS assumed that a hang or cyber attack might be occurring and initiated a graceful restart. This mechanism was tested by intentionally deadlocking the planning thread. The SCFS coordinator, implemented as a privileged Python 3.10.12 process, subscribed to low-level and high-level security events and executed context-dependent responses, such as requesting corroboration from neighboring agents for a sensor-outlier event or refusing an ethically inconsistent action.

5.2. Simulation Environment Setup

We established three simulation environments corresponding to the main application scenarios targeted in this work: smart-city governance, autonomous vehicle traffic systems, and cognitive medical decision support. Each environment included simulated external agents or environmental dynamics together with one or more instances of the proposed AC system.

5.2.1. Smart-City Governance Simulation

We used CityFlow 0.1 and extended it with governance modules. The environment modeled a city with roads, traffic, and public services, while one AC agent acted as a “City Governor AI” that received inputs from multiple departments, including traffic sensors, power-grid status, and emergency calls. Its operational purpose was to optimize traffic flow, energy usage, and emergency response. CityFlow provided the baseline dynamics, and our extensions enabled the AC agent to influence the simulation through actions such as traffic-light reconfiguration and emergency-vehicle dispatch. We ran the environment both with the AC agent and with a baseline management strategy for comparison.

5.2.2. Autonomous Vehicles (IoV) Simulation

We used CARLA 0.9.14 to construct realistic traffic scenarios involving four autonomous car agents, each running the proposed AC stack. The vehicles processed CARLA sensor inputs, performed local DIKWP reasoning, and exchanged semantic messages through DIKWP-SC. The scenario included lane merging, obstacle encounters, and responses to traffic signals, together with adversarial events such as fake GPS signals and false traffic-jam reports. The primary task was safe and efficient navigation; accordingly, we recorded collision events, travel time, and coordination quality, including platooning and conflict avoidance.

5.2.3. Cognitive Medical System Simulation

We built a simplified emergency-room triage simulator in which patient symptoms and vital signs streamed to an AC medical-assistant agent. The agent’s task was diagnosis or prioritization rather than full treatment planning. We constructed a small medical knowledge base and incorporated a GPT-2 small checkpoint through Hugging Face Transformers 4.36.2, fine-tuned on medical question-answering data, into the diagnostic reasoning pipeline. Both normal and difficult cases were tested, including incomplete data, corrupted test results, and malicious input conditions such as tampered laboratory values. The evaluation focused on diagnostic correctness and on the system’s ability to flag anomalies, particularly inconsistencies between clinical signs and laboratory data.

5.2.4. Simulation Execution and Baselines

Each scenario was executed over multiple runs or case batches. The city simulation covered 24 virtual hours per run, the traffic simulation used multiple runs with varied parameters, and the medical setting used batches of synthetic patient cases. The implementation was instrumented to log CPU/GPU utilization, processing latency per cycle, communication bandwidth, decisions, security alerts, and transmitted messages. To maintain realistic complexity, the city scenario included 50 sensors and 10,000 vehicles in the monitored area, the traffic scenario added moderate background traffic and environmental randomness beyond the four AC-controlled vehicles, and the medical scenario used realistic vital-sign ranges together with noisy observations. For comparison, we evaluated the full AC system against four baselines: a system with the same AI components but without the integrated DIKWP architecture, a system without BUG-theory integration, a system with CSFS disabled in selected runs, and, for the city-governance setting, the default CityFlow traffic-light optimization combined with simple emergency-priority rules.

Table 7. Simulation parameters, metrics, and baseline definitions.

Scenario	Scale and Inputs	Perturbations/Adversarial Cases	Primary Metrics	Baseline Definitions
Smart-city governance	CityFlow 0.1 with governance extensions; 24 virtual hours per run; 50 sensors; 10,000 vehicles; traffic, power-grid, and emergency-call inputs	Accidents, congestion peaks, emergency-vehicle dispatch conflicts, inconsistent department-level signals	Congestion duration, emergency response time, decision latency, cross-department action conflicts, resource utilization	Default CityFlow 0.1 traffic-light optimization with simple emergency-priority rules; non-DIKWP stack with similar AI services but no shared semantic-purpose state
IoV/autonomous driving	CARLA 0.9.14 scenario with four AC-controlled vehicles plus background traffic; cameras, GPS, traffic state, lane-merging and obstacle events	Fake GPS, false traffic-jam reports, false hazard broadcasts, partial camera failure, environmental randomness	Collisions, travel time, peak deceleration, throughput, hazard-reaction latency, communication bandwidth	Conventional autonomous-driving stack with local perception and control but no DIKWP-SC; ablations without BUG and without CSFS
Medical triage	Synthetic emergency-room triage batches; 50 representative patient cases; symptoms, vitals, laboratory values, and partial patient records	Incomplete symptom sets, corrupted laboratory results, tampered patient IDs, clinically inconsistent medication recommendations	Diagnostic accuracy, diagnosis time, anomaly flags, false rejection, consistency-check overhead	Diagnostic pipeline with the same GPT-2/knowledge components but without DIKWP integration; ablations without BUG and without CSFS

summarizes the simulation parameters, perturbations, metrics, and baseline definitions used in each scenario.

Table 8. Implementation, simulation, and evaluation setup summary.

Element	Realization in the Prototype	Evaluation Role
Hardware emulation	Multi-GPU subliminal module, pinned CPU consciousness core, CUDA unified memory/high-speed interconnect, FPGA-based network cards for semantic communication and monitoring	Approximates the intended ACPU-style hardware partition
ACOS runtime	Ubuntu Linux 22.04 LTS, Docker 24.0 services, sensor input pipeline, YOLOv3/Darknet-53 vision, speech-to-text and intent recognition, Neo4j 5.14 knowledge graph, fusion daemon, Drools 7.73.0.Final rule engine, PyTorch 2.1.2 RL agent, Redis 7.0.15/shared-memory interaction layer	Implements DIKWP processing, rule-based reasoning, and action execution
Semantic communication	JSON-based DIKWP-SC messages, custom Python 3.10.12 middleware, TLS 1.3/OpenSSL 3.0 encryption, zstd 1.5.5 compression, TCP/UDP transport, multicast for low-latency coordination	Supports semantic sharing and cooperative multi-agent behavior
Security subsystem	Linux Security Modules, threshold rules, scikit-learn 1.3.2 one-class SVM anomaly detection, Drools 7.73.0.Final veto rules, heartbeat monitoring, SCFS restart and corroboration logic	Supports anomaly detection, action validation, safe fallback, and self-recovery
Smart-city simulation	CityFlow 0.1 with governance extensions, one City Governor AI, traffic/power/emergency inputs, AC mode and baseline mode	Tests city-level coordination, congestion control, and emergency response
IoV simulation	CARLA 0.9.14 with four AC vehicles, lane merges, obstacles, traffic signals, fake GPS, and false traffic reports	Tests real-time control, cooperation, and adversarial robustness
Medical simulation	Emergency-room triage environment, symptom and vital-sign streams, medical knowledge base, GPT-2 small checkpoint via Transformers 4.36.2, incomplete and corrupted inputs	Tests diagnostic reasoning and semantic anomaly handling
Execution scale and baselines	24-h city runs, dozens of traffic runs, batches of synthetic patient cases, 50 sensors, 10,000 vehicles, integrated and ablated baselines	Enables repeated-run comparison and component-wise assessment
Logged measurements	CPU/GPU usage, cycle latency, bandwidth, decisions, alerts, transmitted messages, collisions, travel time, and diagnostic outcomes	Supports the quantitative analyses in Section 6

summarizes the principal implementation, simulation, and evaluation settings.

5.3. Runtime–Offline Cost Boundary and Reproducibility

The runtime numbers reported in Section 6 measure online inference, communication, coordination, and recovery after all models and rules have been initialized. They do not include offline model preparation, such as loading pretrained YOLOv3 weights, fine-tuning or preparing the GPT-2 diagnostic component, rule engineering, reinforcement-learning policy training, or knowledge-base construction. No NGSO-based offline optimizer is used in the reported prototype; nevertheless, because offline pre-training can dominate resource-constrained deployment cost, we explicitly separate online runtime cost from offline setup cost.

Let $T_{\mathrm{off}}$ denote one-time offline preparation time, $E_{\mathrm{off}}$ the corresponding offline energy or compute budget, $T_{\mathrm{on}}$ the mean online runtime cost per case or episode, and N the number of deployed cases or episodes. The lifecycle cost should be evaluated as

$$T_{\mathrm{life}}\left(N\right)=T_{\mathrm{off}}+N{T}_{\mathrm{on}},$$

(30)

and analogously for energy or monetary cost. Therefore, a runtime improvement is practically meaningful only after the offline cost has been amortized over a sufficiently large N.

Table 9. Boundary between offline preparation cost and online runtime cost.

Cost Component	Examples in the Prototype	Included in Latency/Throughput Results?	Interpretation
Offline model preparation	Pretrained YOLOv3 weights, GPT-2 medical component preparation, RL policy training, one-class SVM fitting, rule/ontology construction	No	One-time or occasional setup cost; must be reported for lifecycle or resource-constrained deployment claims
Online inference and reasoning	Sensor parsing, graph update, Drools evaluation, RL action selection, DIKWP-SC message handling, CSFS checks	Yes	Basis of the online-runtime and scenario-level comparisons reported in Section 6
Initialization and warm-up	Container launch, graph loading, model loading, middleware startup	Excluded from per-cycle latency; logged separately where available	Startup cost matters for cold-start deployment but not for steady-state online response
NGSO or other offline optimizer	Not used in the reported Figure 3 prototype	Not applicable	Any future optimizer with substantial training cost should be included in $T_{\mathrm{off}}$ and reported separately

summarizes how the current study accounts for offline and online costs. Accordingly, all reported “faster” or “speedup” statements in this paper refer only to online runtime behavior under the initialized prototype configuration, not to total lifecycle cost including model preparation.

For reproducibility, selected supporting materials, including simulation configuration templates, synthetic scenario-generation scripts, sanitized runtime logs, and analysis scripts, are available from the corresponding author upon reasonable request. Third-party simulators such as CityFlow 0.1 and CARLA 0.9.14 should be installed according to their own licenses. Where pretrained model weights cannot be redistributed directly, the authors can provide version identifiers, configuration files, and reproduction instructions needed to reconstruct the pipeline.

5.4. Performance Metrics and Evaluation Methods

We organized the evaluation around four metric families aligned with the design goals.

5.4.1. Cognitive Efficiency

This metric family evaluates how efficiently the system processes inputs and produces decisions. It includes throughput, latency from event perception to action, and CPU/GPU utilization. We also computed an overall ecological computing efficiency, defined as the number of useful inferences produced per second per unit of computing resource. We did not assume a fixed magnitude of improvement a priori; instead, the observed differences were estimated from repeated simulation runs under matched experimental settings.

5.4.2. Real-Time Decision Performance

This metric family evaluates the ability to meet timing constraints. In driving, representative measures include braking-distance margin, reaction time to hazards, and collision-free control under perturbation; in city governance, they include the delay before traffic adjustment following congestion and emergency-response dispatch latency. We measured latency distributions and deadline-miss rates directly from runtime logs and compared them across configurations without prespecifying a target improvement magnitude.

5.4.3. Security and Reliability

This metric family evaluates how effectively the system detects and mitigates attacks or anomalies. In attack-injection experiments, we measured true positives, false negatives, and false positives, together with downtime or performance degradation caused by the security layer. Safety-related improvement was quantified as the observed reduction in incident frequency and/or mitigation delay under the tested attack and fault conditions.

5.4.4. Task Effectiveness

This metric family evaluates whether the system achieves its application-level objectives more effectively. In driving, this includes collisions, traffic-rule violations, and travel time; in city governance, average congestion and emergency response time; and in medical diagnosis, diagnostic accuracy and diagnosis time. Unless otherwise stated, the reported results are descriptive summaries over repeated simulation runs. Because the present study is exploratory and moderate in scale, the comparisons should be interpreted as indicative prototype-level trends unless formal inferential statistics are explicitly reported.

5.4.5. Statistical Reporting

To strengthen the evaluation protocol, we added a statistical reporting plan for repeated-run metrics. For a continuous run-level metric x, we report the sample mean $\overline{x}$, standard deviation s, and $95\%$ confidence interval

$$\overline{x}\pm t_{0.975,n-1}{\displaystyle \frac{s}{\sqrt{n}}},$$

(31)

where n is the number of independent runs or case batches. For non-Gaussian latency traces, bootstrap confidence intervals over runs or cycles are preferred. For binary or count outcomes such as collisions, attack mitigation, and diagnostic correctness, Wilson confidence intervals and Fisher’s exact tests are used when the sample size is sufficient. Figure 4 includes error bars for the relative-change panel; where available, run-level logs and analysis scripts supplied upon reasonable request can support independent recomputation.

Table 10. Statistical treatment for evaluation metrics.

Metric Family	Unit of Analysis	Recommended Interval/Test	Interpretation in This Study
Latency, throughput, CPU/GPU usage	Run-level means and cycle-level traces	Mean ± $95\%$ CI; bootstrap CI for skewed latency distributions; Welch test for baseline comparison	Used as online-runtime indicators; not interpreted as lifecycle speedup including offline preparation
Collision, failure, and attack-mitigation counts	Scenario run or injected attack case	Wilson interval for proportions; Fisher’s exact test for small samples	Reported as controlled simulation evidence, with limited generalization outside the tested scenarios
Diagnostic accuracy and anomaly flags	Synthetic patient case	Wilson interval or binomial test where case-level labels are available	Indicates prototype behavior on the constructed triage cases, not clinical validation
Ablation and SOTA positioning	Component removal or system-class comparison	Matched-compute statistical comparison required for future work	Current ablation table is qualitative and should not be treated as definitive component attribution

specifies the statistical treatment associated with each metric family.

With the implementation completed and the simulation environments prepared, we proceed to the results and discussion, where the DIKWP+BUG-based artificial consciousness ecosystem is compared with alternative system configurations.

6. Experimental Results and Discussion

This section presents the experimental results obtained from the simulations, together with analysis and discussion. We organize the results by scenario and by key performance dimensions, including efficiency, decision-making quality, and security. Comparative analysis with baseline systems is also provided to highlight the improvements introduced by the integrated DIKWP+BUG approach.

6.1. Overall Performance and Efficiency Improvements

Across the tested scenarios, the integrated AC ecosystem showed favorable trends in computational efficiency and responsiveness.

Table 11. Performance comparison between the AC ecosystem and a conventional AI stack.

Metric	DIKWP+BUG AC	Conventional	Improvement
Cognitive throughput	$7.8\mathrm{k}$	$4.5\mathrm{k}$	$+73\%$
Perception–action latency	$120\mathrm{ms}$	$340\mathrm{ms}$	$65\%$ faster
CPU utilization	$68\%$	$95\%$	$-28\%$
Peak memory usage	$5.2\mathrm{GB}$	$5.0\mathrm{GB}$	$+4\%$
Knowledge sync bandwidth	$2.1\mathrm{MB}{\mathrm{s}}^{-1}$	N/A	Enabled sharing
Human overrides	$0/10$ runs	$3/10$ runs	Better autonomy

summarizes representative core performance metrics for our system (“DIKWP+BUG AC System”) versus a baseline conventional AI stack that used similar AI components but lacked the unified DIKWP framework and specialized integration.

Table 11 and Figure 4 summarize the overall performance trends observed in the tested simulation settings. Relative to the selected baseline stack, the prototype showed higher cognitive throughput and lower perception-to-action latency, while also reducing CPU utilization at the cost of a small memory overhead. These values are online-runtime measurements after offline model preparation, initialization, and loading. They should therefore be interpreted as steady-state runtime responsiveness rather than as evidence of lower total training or lifecycle cost. Within this runtime boundary, the results suggest that integrating sensing, reasoning, communication, and safety handling can reduce coordination overhead and improve end-to-end responsiveness.

Similarly, perception-to-action latency, defined as the time from a significant environmental event to the system’s responsive action, was greatly reduced. The typical latency was about $120\mathrm{ms}$ in our system compared with $340\mathrm{ms}$ in the baseline, corresponding to an improvement of approximately $65\%$. In concrete terms, an autonomous vehicle in our system began braking or steering for an obstacle almost a quarter-second faster than the conventional stack, which can be critical in fast-moving traffic. This online runtime latency reduction resulted from several factors: the ACPU’s high-speed semantic interface, concurrent reasoning across cognitive layers, and semantic communication among agents. In one test run, an AC vehicle received a vehicle-to-vehicle message about an obstacle $100\mathrm{m}$ ahead and slowed preemptively even before its own sensors had a clear view, which the baseline system could not do.

We also observed lower CPU utilization in our system, $68\%$ versus $95\%$ in the baseline, indicating more effective use of parallel hardware resources such as GPUs and fewer idle waits. The only area in which our system consumed slightly more resources was memory, with an overhead of about $4\%$, likely due to the storage of semantic tags and additional security and communication metadata. This overhead is modest relative to the benefits gained.

In addition to the aggregate performance metrics, runtime traces suggested a more parallel and less sequential processing pattern in the prototype, with shorter paths between perception, reasoning, and action modules. These observations are consistent with tighter semantic integration within the implementation. However, they should be interpreted as implementation-level indicators rather than as standardized measurements of consciousness or as independent validation of the semantic-flux formalism introduced in Section 3.1.

6.2. Decision-Making Quality and Response in Scenarios

To facilitate cross-scenario comparison,

Table 12. Representative scenario-level outcomes for decision-making quality and response. Relative improvements are reported where absolute baseline values varied across simulation conditions.

Scenario	Representative Task-Level Outcomes	Comparison with Baseline	Robustness/Interpretability Evidence
Smart city governance	Accident recognized within $2\mathrm{s}$; average congestion duration $30\%$ lower; emergency response time improved by approximately $40\%$	Lower congestion and faster dispatch than the baseline	No cross-department action conflicts were observed; logged reasoning traces explained actions in terms of city-level safety and efficiency goals
IoV	0 collisions in the AC condition versus approximately $2/10$ baseline runs; peak deceleration $5.8\mathrm{m}{\mathrm{s}}^{-2}$ vs. $7.1\mathrm{m}{\mathrm{s}}^{-2}$; road throughput improved by approximately $15\%$	Safer and smoother vehicle behavior together with higher traffic efficiency	False hazard messages were rejected through CSFS cross-verification; GPS spoofing triggered alternate localization rather than unstable lane behavior
Cognitive medical assistant	Diagnostic accuracy $92\%$ vs. $85\%$ on 50 simulated cases; average time per case $5\mathrm{s}$ vs. $3\mathrm{s}$	Higher decision quality with a modest time overhead caused by additional consistency checking	Inconsistent laboratory data were flagged for re-test; bogus patient records were rejected before action was taken

summarizes the representative task-level outcomes. Across all three application settings, the proposed system improved decision quality relative to the baseline while also showing stronger robustness under partial, conflicting, or adversarial information.

Across the three application scenarios, the proposed system showed favorable trends relative to the selected baselines, including lower congestion duration in the smart-city setting, fewer collision events in the IoV setting, and higher diagnostic accuracy in the medical-assistant setting. Because these findings were obtained from moderate-scale simulation studies, they should be interpreted as controlled proof-of-concept evidence rather than as definitive evidence of general superiority across real-world deployments.

6.2.1. Smart City Governance

In the smart-city simulation, the proposed system improved both response speed and coordination quality. In a representative accident case, the AC agent recognized the event within $2\mathrm{s}$ using camera feeds and emergency-call data, re-optimized nearby traffic-light timings, and coordinated hospital dispatch autonomously. At the aggregate level, average congestion duration during rush hours was $30\%$ lower than in the baseline, and emergency response time improved by approximately $40\%$. Equally important, no cross-department conflicts were observed. For example, the system avoided issuing a construction roadblock during an evacuation because traffic, energy, and emergency actions were evaluated against a shared Purpose centered on city safety and efficiency. Logged reasoning traces further indicate that the system could explain its interventions in goal-aligned terms, which is important for transparency in governance settings.

6.2.2. IoV

In the IoV scenario, the main gain was the combination of safer control and more coordinated traffic flow. In the four-car test, the AC vehicles exchanged semantic messages about intended maneuvers and detected hazards, which resulted in 0 collisions in the AC condition compared with minor collisions in approximately 2 out of 10 baseline runs. The vehicles also responded more smoothly to sudden obstacles, with average peak deceleration reduced from $7.1\mathrm{m}{\mathrm{s}}^{-2}$ to $5.8\mathrm{m}{\mathrm{s}}^{-2}$, while throughput on the test road segment increased by approximately $15\%$. Robustness tests showed that these gains did not rely on naive trust in communicated messages. When an attacker vehicle broadcast a false “accident ahead” warning, the AC vehicles used CSFS to cross-verify the claim against local sensing and city-camera knowledge and correctly ignored the message. Likewise, during a GPS spoofing event, the SSS detected the anomaly and the affected vehicle switched to visual odometry until GPS readings normalized. These results indicate that the proposed architecture improves safety and efficiency through cooperative, semantically grounded decision-making rather than isolated local control.

6.2.3. Cognitive Medical Assistant

In the medical simulation, the proposed system achieved higher diagnostic quality at the cost of a modest increase in processing time. On 50 simulated patient cases, diagnostic accuracy reached $92\%$ compared with $85\%$ for the baseline, whereas average time per case increased from $3\mathrm{s}$ to $5\mathrm{s}$ because the AC system performed additional consistency checks and iterative refinement when uncertainty remained. The advantage was most evident in difficult cases. In a representative example, the baseline accepted a slightly erroneous laboratory result and produced an incorrect diagnosis, whereas the AC system detected the inconsistency between the laboratory value and the patient’s symptoms and requested a re-test. The security subsystem also rejected a bogus patient record injected into the hospital network after identifying both an invalid patient ID and a medication recommendation inconsistent with any plausible diagnosis. For clinical decision support, these results suggest that the additional response time may be acceptable when it yields better accuracy, stronger anomaly detection, and more clinically interpretable reasoning.

Taken together, the scenario results show that the DIKWP+BUG framework improves not only computational efficiency, as discussed in Section 6.1, but also decision quality under uncertainty, inconsistency, and adversarial interference.

6.3. Security and Robustness Analysis

Table 13. Representative security and robustness outcomes across the evaluated scenarios.

Metric	DIKWP+BUG AC System	Baseline/Comparison	Interpretation
Injected cyber-attack scenarios	$28/30$ thwarted or mitigated; remaining 2 produced only mild transient effects	Baseline systems often experienced more serious consequences under comparable attacks	High attack tolerance with bounded residual impact
Safety-critical failures under malicious or faulty inputs	0 observed	Several incidents observed, including unnecessary abrupt stops induced by false messages	Security controls preserved safe behavior even under adversarial signaling
False security alerts	Approximately 3 across all tests; minor overhead only	Not quantified consistently	Context-aware fusion limited the operational cost of false positives
Autonomous recovery after conscious-process failure	Watchdog restart within $0.5\mathrm{s}$; vehicle coasted safely and resumed operation	Baseline became unresponsive until fallback full stop	Fast self-recovery reduced disruption and preserved safety
Safety incidents or near-misses	About $0.2\mathrm{incidents}{\mathrm{h}}^{-1}$	About $0.7\mathrm{incidents}{\mathrm{h}}^{-1}$	Roughly $70\%$ reduction in active safety incidents
Human intervention during security events	None required	Not reported numerically	Issues were either resolved autonomously or driven to a safe state

summarizes the principal security and fault-tolerance outcomes. Across the evaluated scenarios, the DIKWP-CSFS subsystem improved resistance to malicious inputs and internal faults, reduced safety incidents, and maintained operational continuity with only limited overhead from false alarms.

6.3.1. Attack Resilience and Active Safety

The clearest result is the system’s ability to contain attacks without cascading into unsafe behavior. Across 30 injected cyber-attack scenarios, 28 were either blocked or mitigated, and the remaining 2 produced only mild transient effects, such as momentary sensor-data loss before isolation of the affected channel. No safety-critical failure was observed in the AC condition. By contrast, the baseline systems experienced several incidents, including unnecessary abrupt stops triggered by false messages. At the aggregate level, safety incidents or near-misses were reduced from approximately $0.7$ to $0.2$ per hour of operation, indicating a substantial safety benefit in the tested settings.

6.3.2. Context-Aware Anomaly Handling

A second finding is that the security layer did not operate as a purely rule-based filter. False positives did occur, but their cost remained limited. In one vehicle run, heavy rain noise caused the SSS to suspect sensor tampering; SCFS then fused that alert with wiper status and reduced camera clarity and correctly reclassified the event as a benign environmental disturbance. A similar context-sensitive effect appeared in the medical scenario, where a contradictory laboratory result was treated as a semantic or procedural anomaly requiring verification rather than as random noise to be ignored. These cases suggest that concept-semantic fusion improves discrimination among genuine attacks, environmental disturbances, and ordinary uncertainty.

6.3.3. Self-Recovery and Graceful Degradation

The proposed architecture also showed meaningful resilience after component failure and under incomplete sensing. When the conscious process of a vehicle was intentionally terminated during operation, the SCFS watchdog restarted it within $0.5\mathrm{s}$; during the interruption, the vehicle coasted safely and then resumed normal operation. In the baseline condition, the comparable failure left the vehicle unresponsive until a fallback full stop occurred. More generally, BUG-aware decision-making reduced paralysis under partial information. For example, when two out of five cameras failed, the AC system continued operating cautiously by relying on the remaining sensors and predictive models rather than halting immediately. This form of controlled bug tolerance did not replace verification, but it improved continuity of operation in degraded conditions.

Taken together, these results show that security in the proposed architecture functions as an embedded cognitive capability rather than a detached add-on. By combining low-level anomaly detection, semantic consistency checking, and purpose-aware fallback behavior, the DIKWP-CSFS framework improved attack resistance, limited false-alarm overhead, and preserved safe autonomy without requiring human intervention during testing. Such autonomous security management is particularly relevant for large-scale deployments, such as city-level coordination, where constant human approval is impractical.

6.4. Comparative Analysis with State-of-the-Art Systems

Because the systems compared in

Table 14. Qualitative comparison between the proposed DIKWP+BUG AC system and representative system classes.

System Class	Semantic/Symbolic Reasoning	Real-Time Embodied Deployment	Cross-Agent Coordination	Built-in Safety/Self-Correction	Main Limitation Relative to the Proposed System
Conventional deep learning systems	Limited or implicit	Often possible, but task-specific	Usually weak unless added externally	Typically external to the model	More brittle under out-of-distribution inputs; limited explainability and weak handling of novel situations
Cognitive architectures and LLM-based reasoning systems	Moderate to strong, but often text- or domain-centric	Usually not designed for tight closed-loop hardware control	Limited unless coupled to external orchestration	Inconsistency control is often not intrinsic	Weaker grounding in live devices, real-time control, and semantic self-correction
Integrated autonomous-driving stacks	Strong procedural control, but limited global semantics	Strong for single-vehicle closed-loop control	Usually limited to local coordination	Safety-oriented, but largely pipeline-specific	Less explicit sharing of intent and less purpose-level mediation across agents
Multi-agent systems and IoT frameworks	Rule- or protocol-level semantics	Strong for distributed orchestration	Strong communication, but often protocol-bound	Usually external or rule-based	Harder conflict resolution when objectives compete; less unified semantic integration
DIKWP+BUG AC system (proposed)	Unified DIKWP reasoning across data, knowledge, wisdom, and purpose	Designed for hardware–software co-deployment	Semantic communication with shared-purpose coordination	Embedded CSFS/SCFS monitoring, semantic validation, and safe fallback	Higher tuning complexity and greater system-integration effort

differ substantially in objectives, embodiment, and deployment assumptions, the comparison should be interpreted as qualitative positioning rather than as a strict benchmark. Similarly,

Table 15. Qualitative ablation summary for three key architectural components.

Removed Component	Main Degradation	Primary Role
BUG integration	Over-cautious behavior and delayed decisions under uncertainty, especially in dynamic city and IoV scenarios	Enables bounded action before complete certainty
Semantic communication	Agents operated in isolation and coordination quality deteriorated, most visibly in cooperative driving and city coordination	Provides shared situational awareness and intent exchange
Security subsystem	Normal-condition task output remained similar, but adversarial and inconsistent-input cases became much more damaging	Preserves anomaly rejection, self-correction, and safe fallback

identifies the expected functional role of BUG integration, semantic communication, and CSFS, but it does not replace a full quantitative ablation under matched compute budgets. A more exhaustive ablation study remains an important direction for future work.

6.4.1. Comparison with Representative System Classes

Relative to conventional deep learning systems, the proposed architecture is less dependent on purely task-specific pattern matching and better able to respond to unfamiliar situations through knowledge- and purpose-level reasoning. This distinction was particularly relevant in scenarios where the system had to react to partially novel or ambiguous events rather than merely interpolate within previously observed data. Relative to cognitive architectures and large language model based systems, the main difference is not generic reasoning ability alone but the integration of reasoning with real-time, hardware-aware control and internal semantic consistency checking. This is important in domains such as medical assistance or city coordination, where internally plausible but externally inconsistent outputs are operationally unacceptable.

In comparison with integrated autonomous-driving stacks, the advantage of the proposed system lies less in replacing perception–planning–control decomposition than in augmenting it with shared semantic intent and purpose-level coordination across agents. The cooperative driving results in Section 6.2 illustrate this difference: vehicles were not limited to isolated local control, but exchanged semantic knowledge about hazards and intended maneuvers. Likewise, compared with many multi-agent and IoT frameworks, the proposed system does not rely solely on fixed protocols or a single optimization objective. The Purpose dimension provides a common reference for resolving conflicts among subsystems, which was particularly useful in the smart-city scenario when competing operational goals had to be reconciled without human arbitration.

6.4.2. Ablation and Architectural Synergy

Table 15 shows that the main architectural commitments are complementary rather than redundant. Removing BUG integration made the system slower and more conservative under uncertainty, which undermined its advantage in dynamic settings. Removing semantic communication degraded cross-agent coordination and reduced the benefits seen in cooperative driving and city-scale orchestration. Removing the security subsystem had a smaller effect on nominal-condition task completion but substantially weakened performance in adversarial or inconsistent-input conditions, consistent with the robustness results in Section 6.3. These ablations indicate that the reported gains arise from the combination of semantic structure, bounded bug tolerance, communication, and security rather than from any single component in isolation.

6.4.3. Scalability, Generality, and Remaining Challenges

The experiments were conducted at moderate scale, so claims about large-scale deployment remain inferential. Nevertheless, the results suggest that the architecture is sufficiently general to transfer across multiple domains, because the same DIKWP mesh and CSFS logic supported city governance, IoV control, and medical decision support. As the number of sensors, agents, and decision paths grows, the architecture is expected to benefit from distributed semantic reduction rather than from a strictly layered serial pipeline. The main challenge observed during experimentation was tuning: practical deployment requires a suitable balance between heuristic trust and additional verification, together with appropriate thresholds for attention and deliberation. In this study these parameters were handled with limited adaptive logic, but future work should investigate more systematic calibration, potentially through meta-learning or self-optimization.

Overall, the evidence from Section 6.1, Section 6.2 and Section 6.3 suggests that the DIKWP+BUG AC system occupies a distinctive position among current AI system classes: it combines computational efficiency, cross-agent semantic coordination, and embedded robustness in a way not fully captured by conventional deep learning, text-centric reasoning systems, modular control stacks, or protocol-driven multi-agent frameworks.

6.5. Limitations and Future Research Directions

Although the results are encouraging, the present study has several limitations that should guide future work. First, the reported evaluation is based on runtime emulation and controlled simulations rather than deployment on a fabricated ACPU or a production ACOS. The current implementation therefore demonstrates architectural feasibility and integration behavior, but it does not yet validate hardware-level energy efficiency, timing determinism, thermal behavior, manufacturability, or deployment-grade fault tolerance.

Second, the experiments remain moderate in scale and use selected baseline configurations. Although the simulations cover smart-city governance, IoV coordination, and medical triage, they cannot fully represent the diversity, noise, regulatory constraints, and adversarial complexity of real-world deployments. Future work should therefore use larger scenario suites, standardized benchmarks, matched-compute baselines, and more rigorous comparisons with domain-specific SOTA systems. This is especially important because the qualitative SOTA comparison in Table 14 positions system classes, but it is not a strict benchmark under identical data, compute, and deployment constraints.

Third, the current speed and efficiency claims are restricted to online runtime behavior after model initialization. Offline model preparation, including neural model pretraining or fine-tuning, reinforcement-learning policy training, rule engineering, ontology construction, and knowledge-graph initialization, is not included in the reported latency and throughput values. Therefore, the current results should not be read as evidence of lower end-to-end lifecycle cost in resource-constrained scenarios. Future work should report both offline and online costs, including training time, energy consumption, memory footprint, and amortized cost per deployment episode.

Fourth, several evaluation outcomes are descriptive rather than fully inferential. The current results report observed improvements in throughput, latency, coordination, security response, and task effectiveness, but a more complete validation should include formal statistical testing, confidence intervals, sensitivity analysis, and repeated ablation under controlled compute budgets. In particular, the independent effects of BUG integration, DIKWP-SC, and DIKWP-CSFS should be quantified through systematic component removal, parameter sweeps, and matched-compute experiments.

Fifth, scalability remains an open issue. As the number of sensors, agents, semantic messages, and knowledge-graph nodes grows, DIKWP processing may face graph-expansion overhead, communication congestion, synchronization delays, and increased CSFS monitoring cost. Larger deployments will require distributed graph partitioning, semantic message prioritization, adaptive confidence thresholds, approximate consistency checking, and stronger scheduling policies inside ACOS. The current results therefore support feasibility at the tested scale, but not yet city-scale or clinical-production-scale deployment.

Sixth, the simulations may encode domain and modeling biases. Smart-city behavior depends on the selected CityFlow 0.1 extensions and emergency-priority rules; IoV behavior depends on the chosen CARLA 0.9.14 scenarios, background traffic, and attack patterns; and the medical-triage evaluation depends on synthetic cases, the small knowledge base, and the GPT-2 diagnostic component through Hugging Face Transformers 4.36.2. These choices may favor some reasoning patterns over others. Future work should evaluate demographic, geographic, environmental, and sensor-distribution biases, particularly before applying the system to safety-critical medical or urban-governance decisions.

Seventh, the theoretical constructs of semantic flux, BUG-guided imperfection, and purpose-aligned consistency checking remain only partially operationalized. These concepts are useful for architecture design, but they require more precise metrics, stronger mathematical grounding, and clearer links to measurable system behavior. Future work should refine these metrics and investigate whether they predict robustness, explainability, and decision quality across domains.

Finally, practical deployment will require additional work on governance, human oversight, safety certification, privacy protection, failure accountability, and reproducibility. In safety-critical contexts, the architecture should be integrated with human-in-the-loop review, formal verification where feasible, and external auditing mechanisms. Future research should also investigate adaptive parameter calibration, meta-learning-based threshold adjustment, efficient hardware acceleration, availability of versioned simulator configurations upon reasonable request, and real-world pilots in constrained operational environments.

7. Conclusions

This paper proposed a DIKWP+BUG-oriented architecture for purpose-aware semantic computing and evaluated a prototype runtime realization in simulated smart-city governance, autonomous-driving, and medical-assistant scenarios. The proposed framework formalizes DIKWP as a transformable semantic–cognitive structure, treats BUG theory as a design lens for bounded imperfection and approximate reasoning, and maps these ideas onto four architectural components: ACPU, ACOS, DIKWP-SC, and DIKWP-CSFS.

In the tested simulation settings, the prototype showed favorable trends relative to selected baseline configurations. It achieved higher cognitive throughput, lower perception-to-action latency, improved cross-agent coordination, and stronger resilience against inconsistent or adversarial inputs. These results suggest that organizing computation, communication, reasoning, and security around a shared semantic-purpose structure can improve system-level responsiveness and robustness in complex AI environments.

The findings should be interpreted cautiously. The current work provides prototype-level feasibility evidence rather than a definitive validation of artificial consciousness. The ACPU was emulated rather than fabricated, the evaluation was limited to moderate-scale simulations, the reported speed improvements are online-runtime results that exclude offline model-preparation cost, and theoretical constructs such as semantic flux and BUG-guided imperfection remain only partially operationalized. Stronger baselines, matched-compute comparisons, quantitative ablation, statistical testing, access to supporting reproducibility materials under appropriate licensing, and real-world deployment are still required.

Future work should therefore focus on three priorities: first, developing more rigorous benchmarks and ablation protocols for DIKWP+BUG architectures; second, validating the approach in larger and more realistic embodied environments; and third, refining the security, governance, and alignment mechanisms needed for deployment in safety-critical domains. Under these constraints, the present study contributes an initial architectural and experimental basis for investigating purpose-aware, semantically integrated AI systems.