Non-Interacting Artificial Agents

• Non-interacting artificial agents are computational entities that process data independently with no direct communication, relying on isolated environmental observation and action.
• The A2AI framework partitions agents into perceptive and action units, enforcing strict aspect separation and policy-driven updates to maintain data security.
• Empirical tests highlight robust information security, minimal data leakage, and alignment with cognitive models, underscoring practical benefits in secure processing.

Non-interacting artificial agents are a class of computational entities designed to operate in isolation from each other, with no direct communication or internal information flow between agent processes. Interaction—if any—occurs only indirectly through an external environment, typically mediated by strict policies of observation and action. Research on non-interacting agents spans agentic frameworks for secure information processing as well as models of artificial consciousness that emphasize internal hierarchy without cross-agent exchange.

1. Formal Characterizations and Theoretical Foundations

Non-interacting agents are defined by the absence of direct inter-agent communication and dependency: each agent perceives, reasons, and acts within boundaries strictly enforced by architectural, algorithmic, or policy-level constraints. Two formalizations dominate the literature:

Aspective Agentic AI (A2AI) Framework

In the A2AI model (Bentley et al., 3 Sep 2025), agents inhabit a dynamic, partially observable information system consisting of a global environment $\mathcal{E}$ with state $s_t$ at discrete time $t$. The agent population is partitioned as:

• Perceptive agents (p-agents): Each $p_i$ applies a deterministic projection $\varphi_i: S \to O_i$, yielding a private aspect $A_i$ of the environment (an agent-specific umwelt).
• Action agents (a-agents): Each $a_i$ proposes modifications $\Delta_i$ to $\mathcal{E}$ based exclusively on $A_i$, enforcing strict policy compliance.

Agents observe only their own projected aspect of the environment and submit modifications to $\mathcal{E}$ via authenticated APIs; all interactions among agents are precluded except through this controlled write-back to the environment. The formal partition is:

$$S = \bigcup_{i=1}^k \mathbb{A}_i, \qquad \mathbb{A}_i \cap \mathbb{A}_j = \varnothing \text{ for } i \neq j$$

where $S$ is the set of global states and $A_i$ is the exclusive aspect for agent $i$.

Info-structural Model of Computational Consciousness

The info-structural model for non-interacting agents (Iovane et al., 2022) prescribes a strictly sequential pipeline of cognitive layers:

1. Sensation
2. Perception
3. Emotion
4. Affection
5. Attention
6. Awareness
7. Consciousness

Each processing layer $i$ produces an instance $r_{i,n}$ at timestep $n$ without access to the internal state or outputs of peer agents. The pipeline is modelled as a hierarchy, not a workspace: all operations are internal and bottom-up, with no shared memory or messaging.

2. Core Methodologies and Frameworks

The absence of agent-agent communication necessitates frameworks that rigorously enforce information compartmentalization and environmental mediation.

A2AI Event-driven Architecture

The principal A2AI loop is asynchronous and event-driven:

• Each $p_i$ monitors $\mathcal{E}$ for changes, regenerating its local aspect $A_i$ upon detection.
• Each $a_i$ evaluates $A_i$ for triggers, proposing changes $\Delta_i$ to $\mathcal{E}$, which are then arbitrated in the event of overlapping requests (by aspect priority).
• All state synchronization is environment-driven; agents are notified only via $\mathcal{E}$ updates. There is no peer-to-peer exchange.

Pseudocode summary (see original text for elaborated sketch):

loop forever: for each p_agent[i]: if E.has_changed_since_last_aspect[i]: aspect[i] = p_agent[i].generate_aspect(E.current_text, P_i) for each a_agent[i]: if a_agent[i].detects_trigger(aspect[i]): Δ_i = a_agent[i].propose_change(aspect[i], P_i) submit_request(i, Δ_i) if any change-requests pending: select Δ_winner by priority(Δ.aspect_type) E.apply_change(Δ_winner) notify all p_agents that E changed

Info-structural Consciousness Pipeline

The info-structural model operates with a defined computation for each cognitive layer, such as

$$r_{1,n} = D_1(n, m_{1,n}, x_n, t) = k_{1,n} \alpha_1 \mathrm{thr}_H(x_n) \exp\left[-\frac{t-n}{n}\right] \exp\left[-e^{-\frac{T_1}{n} + \beta_1 m_{1,n}}\right]$$

and analogous equations for $r_{i,n}$. Attention ($r_{5,n}$) is computed via normalized instance matrices, while awareness and consciousness use expectation fusion and graph metrics, respectively. All processing is performed independently within the agent, with no cross-agent leakage.

3. System Architecture and Information Flow

A2AI System Layout

The architecture is characterized by:

• A single, versioned environment document store ($\mathcal{E}$)
• A ring of strictly non-communicating $p$-agents, each with unique prompt templates and memory
• Local $a$-agents for each $p$-agent, collocated to receive only their local aspect
• Centralized arbitration for change requests to $\mathcal{E}$
• Absence of chat- or group-based communication, which stands in contrast to baseline frameworks like AutoGen's Selector and GroupChat (Bentley et al., 3 Sep 2025)

Info-structural Model Organization

Each agent runs an isolated cognitive hierarchy (Sensation→Consciousness), with internal short-term memory and observed visual features. There is no architectural mechanism for agent-to-agent influence; all awareness and consciousness are self-contained, divided into "environment" and "subjective" components by splitting and weighting of internal metrics.

4. Empirical Validation and Performance

Information Security and Leakage

In the A2AI evaluation (Bentley et al., 3 Sep 2025), empirical tests measured breaches as literal propagation of confidential facts (e.g., "100% mortality rate") across aspects. Under three disclosure scenarios:

• AutoGen leaked this information up to 83% of the time (worst-case), whereas A2AI observed zero breaches across 30 runs per scenario.
• All aspects and write proposals were correctly isolated; policy-violating updates (e.g., public access to sensitive data) were systematically blocked.

Functional Alignment with Psychological Evidence

The info-structural consciousness model (Iovane et al., 2022) was validated on visual-emotion stimuli:

• Attention ($r_{5,n}$) mirrored empirical covert-attention results; positive and neutral images had highest scores, disgust and sadness lowest.
• One-way ANOVA across 14 stimuli: $F(13,597) = 434.16, p < 0.001$; emotion effect $F(7,602) = 3101.39, p < 0.001$.
• The awareness index ($r_{6,n}$) increased both with repetition and incomplete information, paralleling psychological masking/repetition findings.
• The moral-graph–based consciousness score ($r_{7,n}$) reproduced patterns from moral-judgment studies, with higher "wrongness" (low $r_{7,n}$) for disgust-laden images.

5. Design Implications and Extensions

Creating Non-interacting Agents

To instantiate non-interacting agents:

1. Assign each agent a private $p$-agent and $a$-agent pair.
2. Apply deterministic aspect projection functions that reveal only authorized data slices.
3. Enforce write-backs via a policy- and version-managed environment with conflict arbitration and access control.

Possible Extensions

Potential extensions include:

• Nested or hierarchical aspects: Build composite roles (meta-agents) by recursively nesting aspect partitions.
• Learning-driven aspects: Evolve aspect assignments based on agent experience or external supervision.
• Transactional environments: Enable rollbacks and formal verification of environment updates.
• Fine-grained security integration: Apply row/column security models at the database level.

Trade-offs and Limitations

Identified trade-offs include:

• Increased system complexity (custom versioning, arbitration, policy layers)
• Latency from environment update propagation (all $p$-agents must re-project after each write)
• Persisting risks from prompt-level adversarial attacks; policy rule definition is critical
• Limited empirical generalization (current results are scope-limited to specific examples)

This suggests the approach prioritizes information security and agent autonomy at the cost of greater implementation overhead and potential efficiency trade-offs.

6. Comparative Perspectives and Broader Impacts

Non-interacting agent paradigms differ fundamentally from classic multi-agent systems that rely on collaborative behaviors or workspace-like shared memory. The strictly compartmentalized structure is well-suited for:

• Applications requiring hard information boundaries (e.g., trusted processing, regulatory compliance)
• Investigations into the emergence of consciousness or self-awareness in strictly private agent streams
• Scalable architectures where each agent's failures or vulnerabilities do not propagate globally

A plausible implication is that non-interacting agent architectures, by sharply minimizing information surfaces between agents, offer operational advantages in settings where security, isolation, and auditability are paramount (Bentley et al., 3 Sep 2025, Iovane et al., 2022). However, such models may be less efficient or flexible in scenarios demanding cooperative behavior or emergent group cognition.