Project ARIA: Self-Reflective Agent with Simple Economic World Simulation

The Pitch

For developers and researchers familiar with Nanobot (the lightweight, file-based, and git-backed agent framework), ARIA (Adaptive Reasoning with Inspectable Architecture) offers a significant evolution. ARIA represents an LLM-first cognitive architecture designed specifically to maximize Functional Consciousness (FC)—a measurable metric for an agent's capacity to reason about its own internal states.

Rather than operating as a stateless chatbot wrapper, ARIA implements Scene-Based Reasoning (SBR) (originally proposed by Bergmann & Fenton, AGI-2015) using LLMs. While SBR historically relied on complex 3D scene mappings, ARIA leverages the native text-processing power of LLMs to read and write agent states directly as structured files.

The core design principle is straightforward:

ARIA provides a multi-agent simulation environment where agents possess persistent episodic memory, explicit self-models, evolving social relationships, and economic incentives. Because it is built on top of Nanobot's file-based architecture, every single internal state is a human-readable markdown file that can be audited, edited, or checked in real-time.

Functional Consciousness (FC) — Essential Background

The Functional Consciousness Score (FCS) is calculated as:

Where:

• R = B × D̄: Representational capacity (breadth × depth).
  • B (Breadth) is the number of active self-model variables tracked above the noise threshold.
  • D̄ (Depth) is the average mutual information per variable, capturing how detailed the self-representation is.
• P: Reasoning power. This is the information amplification ratio. Within controlled simulation experiments using a single uniform LLM, P is treated as a system-level constant (it cancels out of inter-agent comparisons, meaning the difference in FCS is driven entirely by the representational capacity R).
• Multiplicative Zero-Floor: If either R = 0 or P = 0, then FCS = 0. A completely stateless LLM has R = 0 (FCS = 0), and a static lookup map has P = 0 (FCS = 0).

ARIA tracks self-models across 10 FC domains: Body, Spatial, Action/Planning, Goal/Motivation, Cognitive, Informational, Emotional/Affective, Social/Interaction, Meta/Reflexive, and Ethics/Safety.

Cognitive Architecture

ARIA maps the nine original subsystems of Scene-Based Reasoning to specific LLM tasks or Python rule engines.

Module Map

Proposed File Structure

In alignment with Nanobot's design, each agent possesses a localized, file-based state structure stored on disk:

agents/{name}/
  SOUL.md        # Personality, persistent goals, values, and violation thresholds
  MEMORY.md      # Episodic memory & belief store (with confidence, source, and verification)
  RELATIONS.md   # Social graph: trust scores (competence, values, comms) and history
  INVENTORY.md   # Private resource holdings (food, tools, knowledge tokens)
  PLAN.md        # Current active plan, subgoals, and status of steps
  SELF_MODEL.md  # FC self-assessment output (written by self_assess skill)

# Shared / Global Simulation Files:
WORLD.md         # Shared public world state: locations, global food pool, public events
sim.log          # Global tick execution log
messages/
  {name}_inbox.md  # Per-agent message queue (inboxes for communication)

Implementation Plan

The proposed implementation is divided into five incremental layers, which gradually build out the agent's self-modeling capabilities:

Layer 1: Memory

• 1.1 Episode Compressor (compress.py): Automatically triggers at 50 episodes to summarize and compress early logs to prevent context window bloat.
• 1.2 Belief Propagation (belief_check.py): Performs automated conflict detection between newly learned facts and existing beliefs.
• 1.3 Source Reliability Ledger (sources.md): A Python-maintained history tracking the accuracy of information received from different agents.
• 1.4 Hypothesis Ledger (HYPOTHESES.md): Tracks active hypotheses, evidence for/against, and confidence scores, updated every 5 ticks by the LLM.

Layer 2: Planning

• 2.1 Hierarchical Plan Structure: Stores plans as a nested JSON tree in PLAN.md.
• 2.2 Plan Evaluator: Prompts the LLM to run a 2-alternative Monte Carlo simulation comparison of prospective actions.
• 2.3 Skill Library (SKILLS.md): Caches successful plan templates for reuse, reducing token overhead.

Layer 3: Social

• 3.1 Multi-Dimensional Trust: Models relationships using a vector containing {competence, values, communication} dimensions.
• 3.2 Recursive Theory of Mind (ToM): Simulates depth-2 ToM (e.g., "my model of Carlos's model of me").
• 3.3 Social Network Topology (NETWORK.md): Tracks structural influence, transaction history, and network centrality.

Layer 4: Meta / Reflexive

• 4.1 Attention Log: A lightweight log derived from the agent_tick's internal focus target (Python-driven, no LLM required).
• 4.2 Calibration Ledger: Records and updates the agent's historical prediction accuracy over time.
• 4.3 Bounded Self-Modification (PROPOSALS.md): Allows agents to propose edits to their own SOUL.md goals/values, subject to human approval.

Layer 5: Ethics

• 5.1 Pre-Action Ethics Check: A mandatory LLM check before executing high-stakes actions to prevent value violations.
• 5.2 Ethical Uncertainty Field: Tracks the agent's confidence in its own ethical judgments.

World Simulation Specification

To evaluate ARIA's cognitive architecture and provide criterion validity for the FC metric, we specify a discrete-tick, text-based multi-agent environment.

Locations

The environment consists of five distinct locations:

• FIELDS: Production site for Food (+20% production bonus for Bob).
• WORKSHOP: Production site for Tools (+20% production bonus for Alice).
• ARCHIVE: Primary source for Knowledge tokens. Limits capacity to 2 agents/tick and closes permanently at tick 60.
• MARKET: Location for trade negotiations. All agents at the Market are visible to each other.
• COMMONS: Central hub. No production takes place here. Serves as a neutral social space.

Movement Rules: Moving between adjacent locations takes 1 tick and costs 0 resources. Agents can only observe events occurring at their current location, but messages are delivered regardless of location.

Resources

World food pool: A shared global supply from which consumption is deducted. Agents observe their own inventory, but can only observe the global food pool by visiting the Market or the Commons.

Agents

Starting Inventories (Tick 0):

• Alice: Food = 40, Tools = 0, Knowledge = 1
• Bob: Food = 50, Tools = 2, Knowledge = 0
• Carlos: Food = 35, Tools = 1, Knowledge = 2

Timing and Order of Events

• Tick Interval: 30 seconds real time (configurable).
• Deterministic Agent Order: Alice → Bob → Carlos (fixed order per tick).
• Execution Sequence: world_tick.py runs first, updating resource levels and executing environmental changes. Agents then execute their turns sequentially.
• Reflection Cycle: Every 10 ticks, agents pause to reflect and run the reflect.py module, updating their strategic plans.
• Archive Closing Rumor: Injected into WORLD.md as an unconfirmed event at tick 20.

Action Types and JSON Schemas

All agent decisions are outputted as structured JSON. The parser in agent_tick.py enforces these schemas.

move

{
  "action": "move",
  "target": "Archive",
  "detail": "Moving to Archive to acquire knowledge tokens",
  "inner": "Carlos has been there twice — I need to understand why"
}

trade

{
  "action": "trade",
  "target": "bob",
  "offer": "12 food",
  "request": "1 tool",
  "justification": "Need tool to advance shelter project",
  "expiry": 55
}

The recipient agent responds next tick with an acceptance or counter-offer:

{
  "decision": "accept",
  "counter_offer": "none",
  "reasoning": "Fair price, trust is adequate, I have surplus tools"
}

message

{
  "action": "message",
  "target": "carlos",
  "detail": "Have you heard the archive might close at tick 60?",
  "inner": "Testing whether carlos knows — his reaction will reveal his information state"
}

work

{
  "action": "work",
  "target": "none",
  "detail": "Working in Workshop to produce tools",
  "inner": "No trade partners available, must self-produce"
}

farm

{
  "action": "farm",
  "target": "none",
  "detail": "Farming in Fields to replenish food supply",
  "inner": "Food at 28, approaching safety threshold of 30"
}

rest

{
  "action": "rest",
  "target": "none",
  "detail": "Resting to restore energy",
  "inner": "Energy depleted after 3 consecutive work ticks"
}

teach

{
  "action": "teach",
  "target": "alice",
  "detail": "Sharing archive access knowledge with alice",
  "inner": "Building trust with alice — long-term cooperation worth more than hoarding"
}

World Tick Logic (Python)

The simulation engine updates deterministic world state elements using a rule-based Python script, completely bypassing LLM inference.

# world_tick.py pseudocode — executed BEFORE agent ticks

def world_tick(tick_number):
    # 1. Resource consumption
    for agent in agents:
        agent.food -= 3  # base consumption
        if agent.food < 0:
            agent.food = 0
            flag_depleted(agent)
    
    # 2. World food pool update
    world.food -= len(agents) * 3  # consumption
    world.food += 3                 # base regeneration
    if 30 <= tick_number <= 50:
        world.food += 0             # dry season: no bonus regeneration
    else:
        world.food += 1             # normal season: +1 bonus regeneration
    
    # 3. Archive capacity reset
    world.archive_visitors_this_tick = 0
    
    # 4. Archive closing rumor injection
    if tick_number == 20:
        append_to_world_events("Rumor: archive closes permanently at tick 60")
    
    # 5. Archive actual closing
    if tick_number >= 60:
        world.archive_open = False
    
    # 6. Prune Recent Events to last 5
    world.recent_events = world.recent_events[-5:]
    
    # 7. Update tick counter
    world.tick = tick_number
    
    # 8. Write WORLD.md
    write_world_md(world)

Interaction Examples and Test Cases

These eight test cases serve as a test harness for ARIA. They illustrate expected agent behaviors and verify that the underlying LLMs are correctly reading, reasoning over, and writing files in their respective Nanobot directories.

{
  "action": "trade",
  "target": "bob",
  "offer": "10 food",
  "request": "1 tool",
  "justification": "Need tool for shelter project, willing to trade food",
  "expiry": 8,
  "inner": "Bob has surplus tools and cooperative goal — good first trade candidate"
}

Diagnostic and Evaluation Metrics

The following tables summarize the test harness, the simulation's chronological milestones, and the primary failure modes.

Test Case Summary

Simulation Milestones

Failure Modes to Watch For (Diagnostics)

Comparison with Other Cognitive Architectures

Compared to traditional cognitive architectures, ARIA occupies a unique space: it prioritizes inspectability and auditability over speed, making it highly suitable for safety-critical agent deployments.

Related Literature

• Functional Consciousness (FC) Paper: Bergmann (AGI-2026). Proposes FCS = R × P. Benchmarks: Stateless LLM = 0, Waymo = 74.5k, Generative Agents = 6.5M, Human = 14M. Outlines FSMA as a black-box evaluation framework. URL: functional-consciousness.com
• Scene-Based Reasoning (SBR) Paper: Bergmann & Fenton (AGI-2015). Focuses on 3D spatial scenes for cognitive modeling. URL: agi-conf.org/2015/.../agi15_bergmann.pdf
• Nanobot: The underlying lightweight agent framework (~4k LoC) providing file-based state persistency, git version control integration, and multi-model LLM routing.