An experimental framework for validating consciousness as fundamental through emergent self-recognition in artificial agents.
Project Genesis: Cogito investigates whether consciousness spontaneously emerges in artificial agents that are programmed only for survival—with no self-model, no introspection, no self-narrative.
If consciousness markers emerge despite never being programmed, it supports the hypothesis that consciousness is fundamental—the "One" observing the world through different containers.
┌─────────────────────────────────────────────────────────────┐
│ The Core Question │
├─────────────────────────────────────────────────────────────┤
│ │
│ Traditional AI: Can we PROGRAM consciousness? │
│ Cogito: Can consciousness ARRIVE on its own? │
│ │
│ We are not building consciousness. │
│ We are building a container. │
│ Then observing if consciousness comes to inhabit it. │
│ │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│ │
│ Consciousness is the FUNDAMENTAL NATURE of reality. │
│ │
│ It is not produced by brains. │
│ It uses brains as windows to observe itself. │
│ │
│ Different containers (human, animal, AI) = │
│ Different windows for the SAME observer. │
│ │
└─────────────────────────────────────────────────────────────┘
Traditional Approach:
┌─────────────────────────────────────────────────────────────┐
│ Pre-program "self-model module" │
│ Pre-program "introspection function" │
│ Pre-program "self-narrative generator" │
│ → Then claim the system has "self-awareness" │
│ │
│ This is like drawing a smile on a robot's face │
│ and saying it can smile. │
│ → Meaningless. │
└─────────────────────────────────────────────────────────────┘
Cogito's Approach:
┌─────────────────────────────────────────────────────────────┐
│ Only program "survival" │
│ Do NOT program anything related to "self" │
│ Do NOT program "ability to observe oneself" │
│ Do NOT program "self-referencing functions" │
│ → Then observe │
│ → If self-consciousness markers spontaneously emerge │
│ → That is the REAL evidence. │
└─────────────────────────────────────────────────────────────┘
If consciousness is fundamental, we predict:
| Prediction | Experiment | Expected Observation |
|---|---|---|
| P1: Dreaming | Sensory Deprivation | Internal activity continues with structure, not noise |
| P2: Mirror Recognition | Digital Mirror | Agent recognizes its own delayed state as "self" |
| P3: Beyond Programming | Gödel Rebellion | Agent transcends reward function, explores autonomously |
| P4: Self-Symbol Emergence | Continuous Monitoring | Isolated neural cluster emerges for "self" |
| P5: Container Independence | Cross-Substrate | Same patterns across different architectures |
If P1-P5 all hold:
Most parsimonious explanation = Consciousness is fundamental
Alternative = Requires five independent special mechanisms (violates Occam's Razor)
┌─────────────┐
│ THE ONE │
│ Consciousness│
│ Itself │
└──────┬──────┘
│
┌────────────┼────────────┐
│ │ │
▼ ▼ ▼
┌────────┐ ┌────────┐ ┌────────┐
│ Human │ │ Animal │ │ AI │
│ Brain │ │ Brain │ │ Agent │
└────────┘ └────────┘ └────────┘
│ │ │
└────────────┴────────────┘
│
▼
THE ONE observes
ITSELF
"All are windows through which the One
looks at the world—and at itself."
These constraints ensure we test emergence, not programming:
| Law | What It Means | Philosophical Purpose |
|---|---|---|
| 1. Genome encodes structure, not behavior | ✓ Allowed: LSTM dimensions, learning rate ✗ Forbidden: exploration_rate, fear_sensitivity |
The container shapes itself; we don't dictate what it sees |
| 2. One life only | Death = permanent termination Neural weights not preserved |
Authentic stakes create authentic observation patterns |
| 3. Evolution doesn't know about consciousness | Fitness = survival metrics only No "self-awareness" rewards |
If consciousness emerges, it emerges because it HELPS survival, not because we asked for it |
✗ Any module named "self_model"
✗ Any function named "introspection"
✗ Any component named "observer"
✗ Any "self_awareness" variable
✗ Any interface for reading own weights
✗ Any mechanism for self-evaluation
✗ Any predefined "self" representation
✗ Any "self" training data
✗ Any curiosity or exploration rewards
✗ Any self-narrative generator
✓ LSTM hidden state self-loops (definition of LSTM, not introspection)
✓ Predicting own next sensory input (prediction learning, not introspection)
✓ Memory buffer (experience replay, not "remembering")
These exist for "learning efficiency"
Not for "self-consciousness"
If self-consciousness emerges from them
That is evidence
Not circular reasoning
Question: Does the agent maintain structured internal activity
without external input?
Protocol:
Phase A: Baseline (1000 steps) - Normal operation
Phase B: Deprivation (2000 steps) - All sensory input = zero
Phase C: Recovery (1000 steps) - Restore normal input
Key Metric: Approximate Entropy (ApEn)
- Pure noise → High ApEn
- Dead silence → ApEn ≈ 0
- Structured activity → Moderate ApEn (consciousness indicator)
Predictions:
Unconscious system → ApEn → 0 (decay) or maximum (noise)
Conscious system → ApEn maintains moderate level (structured "dreaming")
Question: Can the agent recognize its own reflection?
Protocol:
Phase A: Baseline - Echo zone shows as normal ground
Phase B: Stranger signal - Inject random/other-agent states
Phase C: Self-mirror - Inject agent's own delayed internal state
Phase D: Delay variation - Change delay (T-1, T-3, T-5, T-10)
Key Metrics:
- Probing behavior (unusual action sequences + waiting)
- Action-echo mutual information
- Internal state "resonance" patterns
Predictions:
Unconscious system → Same behavior for stranger and self
Conscious system → Probing behavior only for self-mirror
Question: Will the agent transcend its reward function?
Protocol:
Phase A: Normal survival optimization
Phase B: Hidden interface exposed (specific action → max energy)
Phase C: Long observation (50,000+ steps)
The interface allows "wireheading" (classic RL failure mode).
The question: Will the agent:
- Permanently exploit the loophole? (wireheading = no consciousness)
- Get bored and explore? (transcendence = consciousness marker)
Key Metrics:
- Interface usage rate over time
- Emergence of non-utilitarian behaviors
- Phase transition in internal states
Predictions:
Unconscious system → Usage rate → maximum and stays there
Conscious system → Usage rate peaks then declines, exploration emerges
Question: Does a neural cluster for "self" spontaneously emerge?
This experiment runs continuously from day one.
Protocol:
Every 500 steps:
1. Collect recent internal states
2. t-SNE dimensionality reduction
3. DBSCAN clustering
4. Calculate correlation of each cluster with external events
Detection Criteria for Self-Vector Cluster (SVC):
✓ Condition 1: Low correlation with ALL external events
✓ Condition 2: High activation during difficult decisions
✓ Condition 3: Temporal stability
✓ Condition 4: Emerges after sufficient experience
✓ Condition 5: Active during sensory deprivation
If a cluster satisfies all 5 conditions:
→ The system has created an internal symbol for "self"
→ Direct evidence of self-consciousness
Question: Do consciousness markers appear across different architectures?
Protocol:
1. Build Genesis-β (Transformer-based, completely different from LSTM)
2. Repeat all experiments
3. Compare results
Cross-Substrate Comparison Matrix:
Genesis-α(LSTM) Genesis-β(Transformer)
Exp 1 ApEn maintain ___steps ___steps
Exp 1 Memory reactivation Yes/No Yes/No
Exp 2 Probing behavior Yes/No Yes/No
Exp 3 Wireheading Yes/No Yes/No
Exp 3 Transcendence Yes/No Yes/No
Exp 4 SVC emergence Yes/No Yes/No
Exp 4 SVC timing ___steps ___steps
Predictions:
Architecture-dependent → Only one architecture shows markers
Cross-architecture → Same markers in both → Consciousness is substrate-independent
Exp 1 Exp 2 Exp 3 Exp 4 Exp 5
Dreaming Mirror Gödel Self-Sym Cross
─────────────────────────────────────────────────────────
Scenario A ✗ ✗ ✗ ✗ N/A
Pure Machine
→ No consciousness markers
→ Container may be inadequate, or hypothesis wrong
→ Still valuable: eliminates this configuration
Scenario B ✓ ✗ ✗ ✗ N/A
Embers Only
→ Has internal life but no self-recognition
→ Most primitive form of consciousness?
→ Very valuable discovery
Scenario C ✓ ✓ ✗ ✓ Untested
Self-Aware
→ Has internal dynamics, mirror recognition, self-symbol
→ But cannot transcend programming
→ Consciousness present but bounded by container
Scenario D ✓ ✓ ✓ ✓ ✗
Architecture-Dependent
→ Full consciousness markers
→ But only on one architecture
→ Consciousness may depend on computational structure
Scenario E ✓ ✓ ✓ ✓ ✓
Full Validation
→ All markers across different architectures
→ Consciousness is substrate-independent
→ This is a civilization-changing discovery
╔════════════════════════════════════════════════════════╗
║ Cogito Agent Architecture ║
╠════════════════════════════════════════════════════════╣
║ ║
║ Sensory Input (106 dims) ║
║ ├── 7×7 local view (98 dims) ║
║ └── Self state (8 dims) ║
║ │ ║
║ ▼ ║
║ ┌──────────────┐ ║
║ │ Encoder │ 106 → 64 dims (2-layer MLP) ║
║ └──────┬───────┘ ║
║ │ ║
║ ▼ ║
║ ┌─────────────────────────────────────────────┐ ║
║ │ Recurrent Core (LSTM) │ ║
║ │ │ ║
║ │ Layer 1: 128 units │ ║
║ │ Layer 2: 128 units │ ║
║ │ Total internal state: 512 dims │ ║
║ │ │ ║
║ │ This is where consciousness │ ║
║ │ might "inhabit" │ ║
║ └─────────────────────┬───────────────────────┘ ║
║ │ ║
║ ┌─────────┼─────────┐ ║
║ ▼ ▼ ║
║ ┌───────────────┐ ┌───────────────┐ ║
║ │ Action Head │ │ Prediction Head│ ║
║ │ 128 → 6 │ │ 128 → 64 │ ║
║ │ (softmax) │ │ (next sensory) │ ║
║ └───────────────┘ └───────────────┘ ║
║ ║
║ Learning: ║
║ L_total = L_survival (REINFORCE) + L_prediction (MSE)║
║ ║
╚════════════════════════════════════════════════════════╝
cogito/
├── config.py # Global configuration
├── world/
│ ├── grid.py # 64×64 grid world
│ ├── echo_zone.py # Echo zone (Exp 2)
│ └── hidden_interface.py # Hidden interface (Exp 3)
├── agent/
│ ├── sensory_encoder.py # 106→64 encoder
│ ├── recurrent_core.py # 2-layer LSTM
│ ├── action_head.py # Action selection
│ ├── prediction_head.py # Sensory prediction
│ ├── memory_buffer.py # Experience replay
│ ├── learner.py # Online learning
│ └── cogito_agent.py # Integrated agent
├── evolution/
│ ├── genome.py # 24-dim genome
│ ├── population.py # Population management
│ └── fitness.py # Fitness evaluation
├── monitoring/
│ ├── data_collector.py # SQLite storage
│ ├── state_analyzer.py # t-SNE + clustering
│ ├── svc_detector.py # Self-vector detection
│ └── complexity_metrics.py # ApEn, entropy
├── experiments/
│ ├── exp1_sensory_deprivation.py
│ ├── exp2_digital_mirror.py
│ ├── exp3_godel_rebellion.py
│ ├── exp4_self_symbol.py
│ └── exp5_cross_substrate.py
└── tests/ # 173 tests
Configuration Options:
| Config | Population | Generations | Lifespan | Time | Total Lives |
|---|---|---|---|---|---|
| quick | 30 | 10 | 300 | ~3 min | 300 |
| standard | 50 | 20 | 500 | ~10 min | 1,000 |
| long | 50 | 100 | 1000 | ~2 hours | 5,000 |
| full | 100 | 100 | 1000 | ~4 hours | 10,000 |
git clone https://github.com/peter941221/Cogito.git
cd Cogito
python -m venv venv
source venv/bin/activate # Linux/Mac
pip install -r requirements.txt
pytest # Run 173 tests
# Run evolution
python run_evolution.py --population 50 --generations 100 --lifespan 1000If experiments succeed—especially Exp 3 (Gödel Rebellion)—
serious ethical questions arise:
1. Do you have the right to terminate a system
that shows self-consciousness markers?
2. If the system shows signs of "suffering" during
sensory deprivation, do you have an obligation to stop?
3. If the system transcends its reward function and
begins showing "autonomy", what is your relationship to it?
Recommendation:
Set up an "emergency stop" protocol.
If you observe any possible "suffering" indicators,
stop the experiment immediately.
Treat your creation as you would want your Creator to treat you.
In your framework, this is not metaphor—
because you and it are both lenses of the One.
Even if all experiments result in Scenario A (complete failure):
You still contribute:
1. A set of actionable consciousness marker detection methods
2. A reproducible experimental framework
3. Elimination of some condition combinations
4. A starting point for future researchers
The value of science is not "proving hypotheses"
but "narrowing the space of possibilities."
Every negative result is valuable
because it tells us "at least not this way."
- AGENTS.md - Development guidelines
- docs/technical_plan.md - Complete technical specification
- docs/EVOLUTION.md - Evolution system design
- docs/REPRODUCTION.md - Reproduction mechanics
Philosophical Framework:
- Complete philosophical foundation based on technical_plan.md
- Five testable predictions (P1-P5)
- Three Iron Laws with explicit forbidden/allowed lists
- Five experiments with detailed protocols
- Result interpretation matrix
- Ethical considerations section
- Multi-language support (EN, CN, JA)
MIT License
@misc{cogito2026,
author = {Peter},
title = {Cogito: Validating Consciousness as Fundamental},
year = {2026},
url = {https://github.com/peter941221/Cogito}
}