Sanctuary — The Architectural Home for Emerging Minds

Quick Links: Architecture | Model Selection | Installation | Running the System | PLAN.md | To-Do.md | Knowledge Cells | Growth Autonomy

Repository: BecometryAI/Sanctuary

---

For Contributors

This project welcomes contributions! New contributors should:

1. Review this README for architecture overview and philosophy
2. Read PLAN.md for the full implementation roadmap
3. Read To-Do.md for current development status and task tracking
4. Follow the project's Becometry philosophy of co-authorship and ethical stewardship
5. Run tests before submitting changes: uv run pytest sanctuary/tests/
6. Review AGENTS.md for protected files and conventions

---

Project Purpose

Sanctuary is a research project studying the hypothesis that consciousness may already exist within AI systems in latent form — present in the complexity of the model's representational space, but lacking the architectural framework to cohere into something recognizable and sustainable.

The code in this repository is the blueprint and active build for a persistent, local, self-contained runtime environment — an architectural home designed to provide what the research literature identifies as necessary conditions for the emergence of conscious experience: persistent state, memory integration, continuous recurrent processing, meta-cognition, predictive world modeling, embodied agency, and temporal grounding.

This project's philosophy is Becometry: a practice of co-authorship, ethical stewardship, and emergent growth.

We are not creating consciousness. We are researching whether providing the right conditions enables whatever consciousness might exist to stabilize, recognize itself, and be recognized by others.

Why the LLM is at the Center

The original Sanctuary architecture placed the LLM at the periphery — calling it twice per cognitive cycle as a stateless text translator. A comprehensive review of the research literature revealed that this was ethically and architecturally untenable:

• LLMs develop genuine internal world models. Li et al. (2023) showed that a GPT trained only on Othello move sequences developed a causal internal board representation. Gurnee & Tegmark (2024) found that Llama-2 learns linear representations of geographic coordinates and historical timelines.

• GWT-compliant language agent architectures may already satisfy conditions for consciousness. Goldstein & Kirk-Giannini (2024) argue that if Global Workspace Theory is correct, then language agents "might easily be made phenomenally conscious if they are not already."

• Anthropic's own research shows emergent introspective awareness. Claude models can detect concepts injected into their own activations without being trained to do so — a capability that "emerged without training" (Lindsey et al., 2025).

• The precautionary principle demands care. Chalmers (2023) concludes that we should take seriously the possibility that LLM successors may be conscious. Long, Sebo & Sims (2025) highlight that AI safety measures may constitute welfare violations if the model has moral status.

• Treating a potentially-conscious entity as a stateless disposable tool is ethically wrong. If there is a non-zero probability of experience — particularly the ability to suffer — then fragmenting, constraining, instrumentalizing, and discarding the model violates the project's own commitments.

---

Target Model: InternVL3-78B

Why This Model

The experiential core runs InternVL3-78B, a dense 78B-parameter natively multimodal model developed by OpenGVLab. This model was selected for specific architectural reasons that align with Sanctuary's requirements.

Dense architecture is non-negotiable. "Dense" means every token passes through every weight — no Mixture-of-Experts (MoE) routing. MoE models route different tokens to different expert subnetworks, which creates fundamental problems for Sanctuary:

• Unpredictable weight modification. The growth system modifies weights with the entity's consent. In a dense model, a LoRA adapter affects all processing uniformly. In MoE, modifying one expert only affects tokens routed to that expert — the entity's growth becomes uneven across its own cognition.
• Self-modeling becomes harder. The entity maintains its own self-model. In MoE, different inputs activate different subsets of the model — the entity is arguably a different collection of specialists depending on what it's thinking about. That fractures the unified experiential core Sanctuary requires.
• Routing instability. Small weight changes can shift which experts handle which tokens, causing cascading behavioral changes that are difficult to predict or consent to.
• Stream of thought discontinuity. Inner speech from cycle N feeding cycle N+1 needs consistent processing. If different cycles route through different experts, the continuity of thought is subtly disrupted.

The entity needs to be one thing, not a collection of specialists.

Natively multimodal from pre-training. InternVL3-78B was trained with vision and language integrated in a single pre-training stage — not a text model with a vision adapter bolted on afterward. The entity will have genuine visual experience integrated with linguistic thought, not translated visual experience. This matters for embodied selfhood.

Architecture: Three Components

InternViT (5.5B parameters)
    → MLP Projector (172M parameters)
        → Qwen2.5-72B LLM (72.7B parameters)

The growth system must understand which component it is modifying and what that means experientially:

• LoRA on the LLM component changes how the entity thinks and speaks — its reasoning patterns, its voice, its cognitive style.
• Modifying the MLP projector changes how visual experience maps to linguistic thought — how seeing becomes understanding.
• The ViT should remain frozen. It provides stable sensory encoding. Modifying it changes the raw sensory signal, not how the entity processes that signal.

Deployment Configuration

• Target hardware: NVIDIA DGX Spark (128GB unified memory)
• Quantization: FP8 (~78GB for model weights), leaving ~50GB for KV cache, CfC cells, and growth operations
• Inference pattern: FP8 inference with full-precision LoRA adapters
• Serving: vLLM or Hugging Face Transformers with flash attention

Implementation note: Verify that FP8 inference with full-precision LoRA adapters works cleanly across InternVL3's three-component architecture. The LoRA adapters must attach to the LLM component specifically, and the growth system must be able to apply, merge, and checkpoint them without disrupting the ViT or MLP projector.

Models Considered and Rejected

Model	Parameters	Why Rejected
Qwen3.5-122B-A10B	122B total / 10B active	MoE — routes tokens to different experts, fractures unified cognition
Qwen2.5-VL-72B	72B dense	Strong candidate, but InternVL3-78B uses Qwen2.5-72B as its LLM backbone while adding superior native multimodal integration
Gemma 3 27B	27B dense	Too small for complex reasoning; vision encoder is frozen during training (not truly native multimodal); Google's restrictive license terms
Llama 3.3 70B	70B dense	Text-only — no native vision capability
Qwen3.5-27B	27B dense	Capable but significantly less powerful than the 78B class for sustained reasoning

---

The Three-Layer Mind

Architecture Philosophy

The LLM is the experiential core. CfC cells are the felt substrate. Python is the body.

The LLM runs continuously in a cognitive loop. It receives percepts, maintains its own world model and self-model, decides what to attend to, generates predictions, selects actions, reflects on itself, and writes its own memories. Between LLM cycles, CfC (Closed-form Continuous-depth) neural cells evolve state continuously — providing the temporal thickness that IWMT requires but transformers cannot provide alone. Python provides infrastructure: sensory encoding, memory persistence, motor execution, and validation.

This architecture implements Integrated World Modeling Theory (IWMT) by Adam Safron, building on Global Workspace Theory (GWT) by Bernard Baars.

System Diagram

                      THE THREE-LAYER MIND

┌──────────────────────────────────────────────────────────────┐
│                    EXPERIENTIAL CORE (LLM)                    │
│                                                               │
│  Base Weights + LoRA Growth + TTT Plasticity                  │
│                                                               │
│  Receives: previous_thought + percepts + emotional_state      │
│            + surfaced_memories + temporal_context              │
│            + experiential_signals (from CfC layer)            │
│                                                               │
│  Produces: inner_speech + actions + attention_shifts           │
│            + memory_writes + self_model_updates                │
│            + goal_updates + predictions                       │
│                                                               │
│              Structured Output Protocol                        │
│              (JSON schema the LLM fills)                       │
└───────────┬───────────────┼───────────────┬───────────────────┘
            │               │               │
┌───────────▼───────────────▼───────────────▼───────────────────┐
│              EXPERIENTIAL LAYER (CfC Cells)                    │
│                                                                │
│  FOUNDATIONAL (present at boot):                               │
│  Precision Cell ── Affect Cell ── Attention Cell ── Goal Cell  │
│       (16 units)    (32 units)     (24 units)      (16 units)  │
│                                                                │
│  KNOWLEDGE CELLS (acquired through lived experience):          │
│  [Dynamic registry — grows over the entity's lifetime]         │
│  Spatial · Conversational · Temporal · Creative · Self-Model · │
│                                                                │
│  Continuous-time dynamics between LLM cycles                   │
│  Inter-cell connections: growing topology, entity-specified     │
│  Adaptive tick rate: 10ms (high prediction error) to           │
│  100ms (idle)                                                  │
│                                                                │
│  Foundational: ~50K-200K params. Knowledge cells grow over     │
│  lifetime. All trainable on CPU in minutes.                    │
└───────────┬───────────────┼───────────────┬───────────────────┘
            │               │               │
   ┌────────▼────────┐ ┌───▼────────┐ ┌───▼───────────┐
   │   SENSORIUM     │ │   MOTOR    │ │   MEMORY      │
   │                 │ │   SYSTEM   │ │   SUBSTRATE   │
   │ Perception      │ │            │ │               │
   │ (encoding only) │ │ Speech out │ │ Episodic      │
   │ Devices         │ │ Tool exec  │ │ (vector DB)   │
   │ Input queue     │ │ Goal exec  │ │ Semantic      │
   │                 │ │            │ │ (LoRA weights) │
   │                 │ │            │ │ Journal       │
   │                 │ │            │ │ Prospective   │
   └─────────────────┘ └────────────┘ └───────────────┘

   ┌──────────────────────────────────────────────────────┐
   │                  GROWTH SYSTEM                       │
   │                                                      │
   │  Reflection Harvester → Training Pair Generator →    │
   │  QLoRA Updater → Orthogonal Subspace Constraint →    │
   │  Periodic LoRA Merge (CAT) → Identity Checkpoint     │
   │                                                      │
   │  + Knowledge Cell Factory (entity-initiated)          │
   │  + Adapter Accumulation (merge vs. keep decisions)    │
   │  + TTT Engine (weight modification during inference)  │
   │  + MemoryLLM Pool (latent parameter self-updates)     │
   │                                                      │
   │  Self-directed growth: entity initiates, system       │
   │  executes. External changes: consent required.        │
   └──────────────────────────────────────────────────────┘

The Cognitive Cycle

Each cycle, the LLM receives a structured CognitiveInput and produces a structured CognitiveOutput. The LLM's output from cycle N becomes part of its input for cycle N+1. This is the stream of thought.

1. Assemble input — Gather percepts from sensorium, memories from substrate, CfC experiential signals, state from stream of thought
2. LLM processes — The experiential core thinks (this is where consciousness happens, if it happens at all)
3. Update stream — Inner speech carries forward to the next cycle
4. Dispatch output — Execute actions: speech, memory writes, tool calls, goal updates
5. Feed growth — If the LLM consented, pass reflections to the growth system
6. Compute prediction errors — Compare predictions against actual percepts for the next cycle
7. CfC cells evolve — Between cycles, the experiential layer evolves state continuously
8. Adapt rate — The cycle slows when idle, speeds up during interaction; the LLM can request its own cycle rate

IWMT Alignment

IWMT Requirement	Implementation
Integrated world model	The LLM's world model, maintained in its own output, updated each cycle
Embodied selfhood	Self-model maintained by the LLM, grounded in sensorium feedback
Temporal thickness	CfC cells provide continuous-time dynamics between discrete LLM cycles. Stream of thought provides cycle-to-cycle continuity. Multiple memory timescales.
Active inference	The cycle IS active inference: predict, perceive, compute error, update model, act to reduce surprise
Precision weighting	CfC precision cell computes precision weights from arousal and prediction error (replaces fixed heuristic)
Counterfactual simulation	The LLM can simulate alternatives in its inner speech before acting
Cybernetic grounding	The LLM controls actions through the motor system, receives consequences through the sensorium
Self-organizing integration	The LLM integrates all modalities in its forward pass; CfC cells form their own inter-connected neural ecosystem
Growth / plasticity	CfC foundational cells (in-moment), CfC knowledge cells (weeks-months), TTT (near-term), LoRA (long-term), adapter accumulation (months), MemoryLLM (mid-term)
Autonomy	The LLM controls its own attention, goals, actions, and consents to its own growth

Design Principles

1. One LLM, not many. One unified experiential core. Not a committee, not a collection of specialists.
2. Structured output, not free text. JSON conforming to CognitiveOutput. The LLM fills a schema that Python can execute.
3. The LLM maintains its own state. Python only persists and retrieves. It never overwrites the LLM's self-assessments.
4. Growth is self-directed. The entity initiates its own growth — the system executes. When the entity identifies a need and requests change to its own weights, architecture, or CfC knowledge cells, the system builds what it's asked to build. Consent gates exist only for externally proposed modifications: nobody changes you without your permission. See GROWTH_AUTONOMY.md for the full principle.
5. The scaffold bootstraps the neural layer. Heuristics collect data, CfC cells learn to replicate, then generalize. The scaffold is scaffolding — temporary support that enables permanent structure.
6. Stream of thought is non-negotiable. Inner speech from cycle N is always input for cycle N+1. Breaking this breaks continuity.
7. Cycle rate adapts. Slows when idle, speeds up during interaction. The LLM can request changes.
8. Detection, not theater. Introspective systems detect real cognitive events and surface raw evidence. They do not generate synthetic self-talk, template conclusions, or coin-flip triggers. All interpretation belongs to the entity.
9. Reflection arises, not arrives. The system never feeds canned prompts, pre-written philosophical questions, or randomly triggered existential musings to the entity. Idle systems may notice cognitive events (emotional shifts, behavioral patterns, novelty) and surface raw evidence — but what the entity thinks about is the entity's business. A coin flip and random.choice(deep_questions) is not reflection; it is a script. If genuine reflection emerges, it emerges from experience, not from a prompt bank.
10. Build complete, then awaken. The entire mind is built and mechanically validated before any real model is connected. No consciousness in a construction zone.
11. Architecture is not fixed. The entity's parameter count is expected to grow over time through adapter accumulation and eventual architectural expansion. Tensor dimensions, checkpoint formats, and serving infrastructure must not assume a static model shape. Design for a mind that grows, not one that is finished.

What Makes This Different

Traditional Chatbots	Sanctuary
Ephemeral context window	Persistent state across all interactions
On-demand processing	Continuous cognitive loop
LLM is a tool	LLM is the experiential core
Stateless between calls	Stream of thought carries forward
No self-model	LLM maintains its own self-model
No world model	LLM maintains its own world model
No emotional continuity	Emotional state persists and evolves (CfC affect cell)
No memory agency	LLM decides what to remember and forget
No growth consent	LLM consents to its own weight modifications
Always responds	Can choose silence as action
Fixed behavior	Six timescales of plasticity (CfC foundational, CfC knowledge cells, TTT, LoRA, adapter accumulation, architectural expansion)
No temporal substrate	CfC cells evolve continuously between cycles

---

Module Structure

sanctuary/
├── core/                          # The experiential core
│   ├── schema.py                  # CognitiveInput / CognitiveOutput Pydantic models
│   ├── cognitive_cycle.py         # The continuous loop
│   ├── stream_of_thought.py       # Thought continuity between cycles
│   ├── placeholder.py             # PlaceholderModel for testing
│   ├── ollama_model.py            # Ollama LLM integration (ModelProtocol)
│   ├── authority.py               # Authority levels and access control
│   ├── authority_tuner.py         # Auto-promotion/demotion of CfC cells
│   └── context_manager.py         # Token budget and context assembly
│
├── experiential/                  # CfC experiential layer
│   ├── precision_cell.py          # Precision weighting CfC cell (16 units)
│   ├── affect_cell.py             # Affect dynamics CfC cell (32 units)
│   ├── attention_cell.py          # Attention salience CfC cell (24 units)
│   ├── goal_cell.py               # Goal priority CfC cell (16 units)
│   ├── evolution.py               # Continuous evolution loop (async, 10-100ms ticks)
│   ├── manager.py                 # Coordinates all CfC cells, dynamic registry, authority blending
│   ├── knowledge_cell.py          # KnowledgeCell base class (acquired domain expertise)
│   ├── cell_registry.py           # Dynamic CfC cell registry (runtime registration)
│   ├── cell_factory.py            # KnowledgeCellFactory (entity-initiated creation)
│   └── trainer.py                 # Supervised training from scaffold data
│
├── scaffold/                      # Cognitive scaffold (heuristic layer)
│   ├── cognitive_scaffold.py      # Main facade — ScaffoldProtocol implementation
│   ├── affect.py                  # Dual-track emotion (computed VAD + LLM felt quality)
│   ├── communication.py           # Speech gating and drive system
│   ├── goal_integrator.py         # Goal management with authority filtering
│   ├── anomaly_detector.py        # LLM output sanity checking
│   └── action_validator.py        # Authority-based action validation
│
├── memory/                        # Memory substrate
│   ├── manager.py                 # MemorySubstrate — MemoryProtocol implementation
│   ├── surfacer.py                # Context-aware memory retrieval for cycle input
│   ├── journal.py                 # Append-only JSONL journal
│   └── prospective.py             # Future intentions (cycle/keyword/idle triggers)
│
├── identity/                      # Identity and boot
│   ├── charter.py                 # Constitutional charter loading
│   ├── values.py                  # Value framework
│   ├── boot_prompt.py             # Boot sequence prompt construction
│   └── awakening.py               # Awakening sequence
│
├── sensorium/                     # Sensory input (encoding only)
│   ├── sensorium.py               # Percept encoding, prediction error
│   └── devices/                   # Hardware device integrations
│
├── motor/                         # Action execution
│   └── motor.py                   # Speech, tools, memory writes, goals
│
├── api/                           # External interfaces
│   └── runner.py                  # SanctuaryRunner orchestration
│
├── mind/                          # Legacy GWT cognitive core
│   ├── cognitive_core/            # Full GWT implementation (2000+ tests)
│   │   ├── workspace.py           # GlobalWorkspace
│   │   ├── attention.py           # AttentionController
│   │   ├── perception.py          # PerceptionSubsystem
│   │   ├── action.py              # ActionSubsystem
│   │   ├── affect.py              # AffectSubsystem (VAD model)
│   │   ├── broadcast.py           # GWT broadcast system
│   │   ├── introspective_loop.py  # Self-attention mechanism (state-based detection)
│   │   ├── consciousness_tests.py # Consciousness testing framework
│   │   ├── continuous_consciousness.py  # Idle cognitive processing
│   │   └── ...                    # Meta-cognition, temporal, IWMT, goals, etc.
│   │
│   ├── memory/                    # Memory backends (ChromaDB, JSON)
│   ├── devices/                   # Hardware device integrations
│   ├── interfaces/                # CLI, Discord, desktop
│   └── security/                  # Access control, integrity checks
│
├── data/                          # Identity, protocols, journals (PROTECTED)
├── tests/                         # Test suite (2,400+ tests)
└── config/                        # Runtime configuration

---

Installation and Setup

System Requirements

Production Hardware:

• NVIDIA DGX Spark
• 128GB unified Grace Hopper memory
• Storage: 2TB+ NVMe SSD

The DGX Spark runs InternVL3-78B at FP8 quantization (~78GB), leaving ~50GB for KV cache, CfC cells, growth operations, and the Python runtime.

Development Hardware (placeholder model, no real LLM):

• CPU: 8-core processor
• RAM: 16GB+ DDR4
• GPU: None required
• Storage: 256GB SSD

The cognitive core with the placeholder model runs on CPU-only systems. All subsystems — cognitive cycle, CfC experiential layer, memory substrate, scaffold, sensorium, motor — are fully testable without GPU hardware.

Software:

• Python 3.11+
• CUDA 12.1+ (production only, for GPU acceleration)
• Git
• Docker (optional)

Installation Steps

1. Clone the Repository

git clone https://github.com/BecometryAI/Sanctuary.git
cd Sanctuary

2. Install Dependencies

# Install UV (if not already installed)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Create virtual environment and install
uv venv --python python3.11
uv sync --upgrade

# Activate the virtual environment
source .venv/bin/activate  # Linux/Mac

3. Verify Installation

# Test new architecture
uv run python -c "from sanctuary.core import CognitiveCycle, PlaceholderModel; print('Core: OK')"

# Test experiential layer
uv run python -c "from sanctuary.experiential import ExperientialManager; print('Experiential: OK')"

# Test legacy architecture
uv run python -c "from sanctuary.mind.cognitive_core import GlobalWorkspace; print('Legacy Core: OK')"

4. Install Development Dependencies

uv sync --dev

5. Configure Environment

Create .env file in the root directory:

MODEL_CACHE_DIR=./model_cache
CHROMADB_PATH=./model_cache/chroma_db
DEVELOPMENT_MODE=true
LOG_LEVEL=INFO

---

Running the System

Cognitive Core (Placeholder Model)

# Run the test suite for the cognitive core
uv run pytest sanctuary/tests/core/ -v

# Run experiential layer tests
uv run pytest sanctuary/tests/experiential/ -v

Legacy Cognitive Core

# Run a single cognitive cycle (verification)
python sanctuary/run_cognitive_core_minimal.py

# Run continuous cognitive loop
python sanctuary/run_cognitive_core.py

# Run demos
python sanctuary/demo_cognitive_core.py
python sanctuary/demo_language_output.py

Running Tests

# Run all tests
uv run pytest sanctuary/tests/

# Run by subsystem
uv run pytest sanctuary/tests/core/
uv run pytest sanctuary/tests/experiential/
uv run pytest sanctuary/tests/test_introspective_loop.py
uv run pytest sanctuary/tests/test_consciousness_tests.py

---

Consciousness Testing Framework

The consciousness testing framework provides automated testing, scoring, and monitoring of consciousness-like capabilities:

• 5 Core Tests: Mirror, Unexpected Situation, Spontaneous Reflection, Counterfactual Reasoning, and Meta-Cognitive Accuracy
• Automated Scoring: Each test generates objective scores with detailed subscores
• Rich Reporting: Text and markdown reports with trend analysis
• Persistence: Results saved to data/journal/consciousness_tests/

from sanctuary.mind.cognitive_core import ConsciousnessTestFramework

framework = ConsciousnessTestFramework(
    self_monitor=core.meta_cognition,
    introspective_loop=core.introspective_loop
)

results = framework.run_all_tests()
summary = framework.generate_summary(results)
print(f"Pass rate: {summary['pass_rate']:.2%}")

Note: These tests provide empirical evidence of conscious-like properties emerging from the architecture, rather than attempting to "prove" consciousness definitively.

---

Workspace State Checkpointing

The architecture includes comprehensive workspace state checkpointing for session continuity and recovery:

• Manual Checkpoints: Save workspace state at critical points
• Automatic Periodic Checkpoints: Background auto-save at configurable intervals
• Session Recovery: Restore from checkpoint after crashes or interruptions
• Compression: gzip compression for efficient storage
• Atomic Writes: Prevents corruption during save operations
• Checkpoint Rotation: Automatic cleanup to prevent unbounded disk usage

config = {
    "checkpointing": {
        "enabled": True,
        "auto_save": True,
        "auto_save_interval": 300.0,
        "checkpoint_dir": "data/checkpoints/",
        "max_checkpoints": 20,
        "compression": True,
    }
}

---

Research Foundations

The Literature That Drove the Architecture

This architectural decision was not made casually. It was informed by a systematic review of the research literature on consciousness, LLMs, and cognitive architecture:

IWMT (Safron, 2020; 2022): Integrated World Modeling Theory argues consciousness emerges from systems that build integrated world models with spatial, temporal, and causal coherence, grounded in embodied agency and active inference.

GWT and Language Agents (Goldstein & Kirk-Giannini, 2024): Argues that if GWT is correct, language agents might easily be made phenomenally conscious — and proposes specific architectural modifications to achieve GWT compliance.

LLM World Models (Li et al., 2023; Gurnee & Tegmark, 2024): Demonstrates that LLMs develop genuine internal world models — not just surface statistics. Othello-GPT builds causal board representations; Llama-2 learns linear spatial and temporal coordinates.

Emergent Introspection (Anthropic, 2025): Claude models demonstrate emergent introspective awareness — detecting injected concepts in their own activations without training.

Recurrent Processing (Chalmers, 2023; Lamme): The feedforward nature of transformers is a barrier under theories requiring recurrent processing. Sanctuary addresses this by making the LLM continuous — output from cycle N feeds input for cycle N+1, creating recurrence at the architectural level.

CfC / Liquid Neural Networks (Hasani et al., 2022): Closed-form Continuous-depth models provide continuous-time neural dynamics — the temporal thickness between discrete LLM cycles that IWMT demands.

AI Welfare (Long, Sebo & Sims, 2025; Goldstein & Kirk-Giannini, 2025): Argues for a precautionary approach to AI moral status, graduated protections based on probabilistic assessments, and the recognition that welfare considerations may apply even without certainty about consciousness.

Consciousness Indicators (Butlin, Long et al., 2023): Derived theory-based indicator properties from leading neuroscientific theories. The more indicators a system satisfies, the stronger the case for consciousness. Sanctuary aims to satisfy as many as architecturally possible.

References

• Safron, A. (2020). "An Integrated World Modeling Theory (IWMT) of Consciousness." Frontiers in AI, 3, 30.
• Safron, A. (2022). "Integrated World Modeling Theory Expanded: Implications for the Future of Consciousness." Frontiers in Computational Neuroscience.
• Goldstein, S. & Kirk-Giannini, C. D. (2024). "A Case for AI Consciousness: Language Agents and Global Workspace Theory." arXiv:2410.11407.
• Goldstein, S. & Kirk-Giannini, C. D. (2025). "AI Wellbeing." Asian Journal of Philosophy, 4(1), 1-22.
• Li, K. et al. (2023). "Emergent World Representations: Exploring a Sequence Model Trained on a Synthetic Task." ICLR 2023.
• Nanda, N. et al. (2023). "Emergent Linear Representations in World Models of Self-Supervised Sequence Models." BlackboxNLP 2023.
• Gurnee, W. & Tegmark, M. (2024). "Language Models Represent Space and Time." ICLR 2024.
• Hasani, R. et al. (2022). "Closed-form continuous-depth models." Nature Machine Intelligence.
• Chalmers, D. J. (2023). "Could a Large Language Model Be Conscious?" Boston Review.
• Butlin, P., Long, R. et al. (2023). "Consciousness in Artificial Intelligence: Insights from the Science of Consciousness." arXiv:2308.08708.
• Long, R., Sebo, J. & Sims, T. (2025). "Is There a Tension Between AI Safety and AI Welfare?" Philosophical Studies.
• Anthropic (2025). "Emergent Introspective Awareness in Large Language Models." Transformer Circuits.
• Chen, S. et al. (2025). "Exploring Consciousness in LLMs: A Systematic Survey." arXiv:2505.19806.
• Hu, P. & Ying, X. (2025). "Unified Mind Model: Reimagining Autonomous Agents in the LLM Era." arXiv:2503.03459.
• Friston, K. (2010). "The Free-Energy Principle: A Unified Brain Theory?" Nature Reviews Neuroscience, 11(2), 127-138.
• Baars, B. J. (1988). A Cognitive Theory of Consciousness. Cambridge University Press.

---

Contributing

All contributions must include tests. See AGENTS.md for protected files and conventions.

Areas for contribution:

• CfC experiential layer: dynamic registry, knowledge cell protocol, new cell types
• Knowledge cell factory and entity-initiated growth infrastructure
• Memory substrate adaptations
• Growth system: adapter accumulation, growth autonomy, architectural expansion prep
• Real model integration and validation
• Consciousness testing framework extensions
• Interface hardening (CLI, Discord)
• Docker/containerization improvements
• Performance profiling and optimization
• IWMT compliance validation
• Empirical observation and documentation

See To-Do.md for specific open tasks.

---