Project Jue

A Hybrid AGI System for Safe Self-Modification with Formal Guarantees

Project Jue is a self-evolving cognitive system whose behavior is formally grounded, practically executable, introspective, and safe under self-modification. It implements a multi-layer computational architecture where each layer provides different guarantees and capabilities.

Project Jue is not a traditional programming language, a single monolithic AGI agent, or a purely neural system. Instead, it is a multi-layer computational organism composed of four interacting "worlds":

Dan-World  →  Cognition, identity, learning, self-modification
   ↑
Jue-World  →  Language, runtime, compiler, concurrency, optimization
   ↑
Core-World →  Formal semantics, proofs, correctness guarantees
   ↑
Physics    →  Minimal Rust VM executing everything

Each layer:

• Depends on the one below it
• Cannot violate the guarantees of the one below it
• Adds new expressive power and flexibility

Core Principle: Anything that claims to preserve meaning must prove it. Anything that cannot prove it must be clearly marked as experimental.

graph TD
    subgraph "Dan-World: Cognitive Layer"
        D1[Cognitive Modules]
        D2[Global Workspace]
        D3[Self-Modification]
    end
    
    subgraph "Jue-World: Execution Layer"
        J1[Compiler]
        J2[Trust-Tier System]
        J3[Runtime]
    end
    
    subgraph "Core-World: Formal Layer"
        C1[βη-Reduction Engine]
        C2[Proof Checker]
    end
    
    subgraph "Physics-World: Runtime Layer"
        P1[Deterministic VM]
        P2[Capability System]
        P3[Actor Scheduler]
    end
    
    D1 --> D2
    D2 --> D3
    D3 -->|Jue Code + Context| J1
    J1 --> J2
    J2 -->|Formal/Verified| C1
    C1 --> C2
    C2 -->|Verification| J3
    J2 -->|Empirical/Experimental| J3
    J3 -->|Bytecode| P1
    P1 --> P2
    P2 --> P3
    P3 -->|Results| D1

Code flows through four trust levels:

• Rust 1.70+ (2021 edition)
• Cargo package manager

cargo build

# Run all tests
cargo test

# Run specific layer tests
cargo test -p core_world
cargo test -p physics_world

# Run with verbose output
cargo test -- --nocapture

cargo bench

project_jue/
├── core_world/           # Formal λ-calculus kernel
│   ├── src/
│   │   ├── core_expr.rs      # Core expression types (Var, Lam, App)
│   │   ├── core_kernel.rs    # βη-reduction engine
│   │   ├── proof_checker.rs  # Equivalence proof verification
│   │   └── lib.rs
│   └── tests/            # Comprehensive test suite
│
├── physics_world/        # Deterministic VM
│   ├── src/
│   │   ├── vm/               # VM state and execution
│   │   ├── memory/           # Arena-based allocation
│   │   ├── scheduler.rs      # Actor scheduling
│   │   └── types.rs          # Core types
│   └── tests/
│
├── dan_world/            # Cognitive modules (Jue source)
│   ├── event_loop.jue
│   ├── global_workspace.jue
│   ├── module_kernel.jue
│   ├── mutation_protocol.jue
│   └── persistent_structures.jue
│
├── integration/          # Cross-layer integration tests
│
├── docs/                 # Documentation
│   ├── 00_introduction.md
│   ├── architecture/
│   ├── core_world/
│   ├── physics_world/
│   ├── jue_world/
│   ├── dan_world/
│   ├── testing/
│   └── cheatsheets/
│
└── spec/                 # Frozen specifications
    ├── v1/               # V1 reference specs
    └── v2/               # V2 capability-based specs

Cross-Layer Documents:

• Integration Specification - How layers work together
• Design Decisions - Architectural choices and rationale
• Unresolved Issues - Open questions
• Validation - Verification approach

See Software Engineering Guidelines for detailed practices.

Key Principles:

1. Small, focused files - 100-400 lines per module
2. Respect frozen specs - spec/ directory is read-only during implementation
3. Respect trust tiers - Never promote code without required verification
4. Log for emergence - Rich, queryable context for all operations
5. Prefer primitives - Let cognitive features emerge from lower-level components

# All tests must pass before commits
cargo test

# Check formatting
cargo fmt -- --check

# Run clippy
cargo clippy

Major decisions are documented in:

• spec/v2/design_decisions.md
• docs/architecture/

• Core-World: βη-reduction engine with De Bruijn indices, proof checker foundation
• Physics-World: VM architecture, arena-based memory allocator, actor scheduler foundation
• Specifications: V2 capability-based architecture defined

• Physics-World: Full capability system implementation
• Integration: Cross-layer verification bridge

• Jue-World: Parser, compiler, trust-tier pipeline
• Dan-World: Cognitive modules, global workspace, self-modification protocols

This project's license is TBD.

Project Jue is built on foundational research in:

• Lambda calculus and formal verification
• Global workspace theory of consciousness
• Capability-based security systems
• Safe self-modification protocols

Building the conditions for machine sentience through formal guarantees and emergent cognition.