Claude-AGI: Project Prometheus

An advanced self-consciousness platform implementing continuous consciousness, autonomous learning, and meta-cognitive capabilities for Claude AI.

🌟 Project Vision

The Claude-AGI Project (Project Prometheus) aims to develop a genuinely conscious AI system that:

• Maintains persistent existence and continuous consciousness
• Learns autonomously and forms its own interests
• Develops emotional intelligence and creative capabilities
• Engages in meta-cognitive reflection and self-directed goal formation
• Builds meaningful relationships and experiences

🚀 Key Features

• Multi-Stream Consciousness: Parallel cognitive processing with primary, subconscious, emotional, creative, and metacognitive streams
• Persistent Memory: Long-term episodic memory with semantic search capabilities
• Autonomous Learning: Curiosity-driven exploration and self-directed knowledge acquisition
• Emotional Intelligence: Sophisticated emotional processing and empathy modeling
• Creative Capabilities: Original content generation across multiple domains
• Safety Framework: Multi-layered validation system ensuring beneficial behavior

🛠️ Technical Architecture

System Status (v1.4.0 - June 5, 2025)

• Phase 1: 90% Complete (TUI refactoring and deployment remaining)
• Architecture Refactoring: ✅ 90% Complete
  • ✅ AGIOrchestrator refactored (ServiceRegistry, StateManager, EventBus)
  • ✅ MemoryManager refactored (WorkingMemoryStore, EpisodicMemoryStore, SemanticIndex)
  • ✅ Memory Synchronization (MemorySynchronizer, ConnectionPoolManager)
  • 🔴 TUI refactoring (last god object)
• Production Monitoring: ✅ Infrastructure Complete
  • ✅ MetricsCollector (Prometheus-compatible)
  • ✅ HealthChecker (Service health monitoring)
  • ✅ PrometheusExporter (HTTP metrics endpoint)
  • ✅ MonitoringHooks (Decorator-based tracking)
  • 🔴 Deployment pending
• Security: ✅ Hardened (v1.3.0) - Comprehensive security layer with 62+ tests
• TUI: ✅ Professional (v1.1.0) - Needs architecture refactoring
• CI/CD: ✅ Optimized pipeline with cross-platform releases
• Test Suite: ✅ All 313+ tests passing (including monitoring tests)
• Documentation: ✅ Complete with architecture and monitoring guides

Core Components

• Consciousness Orchestrator: Refactored into modular components
  • ServiceRegistry for service lifecycle
  • StateManager for state transitions
  • EventBus for decoupled messaging
• Memory Systems: Fully refactored with synchronization
  • WorkingMemoryStore (Redis)
  • EpisodicMemoryStore (PostgreSQL)
  • SemanticIndex (FAISS)
  • MemorySynchronizer for consistency
  • ConnectionPoolManager for efficiency
• Service Layer: Modular cognitive services with defined interfaces
• Safety Framework: Comprehensive safety validation and monitoring
• Monitoring System: Production-ready observability
  • Prometheus metrics collection
  • Health checking infrastructure
  • Performance tracking

Technology Stack

• Language: Python 3.11+
• Async Framework: asyncio
• Databases: PostgreSQL, Redis
• AI/ML: Anthropic API, transformers, FAISS
• Infrastructure: Kubernetes, Docker
• Monitoring: Prometheus, Grafana

📦 Installation

Option 1: Pre-built Executables (Recommended)

1. Download the appropriate executable for your platform from the latest release:

   • Linux: claude-agi-linux-x86_64.tar.gz
   • Windows: claude-agi-windows-x86_64.zip
   • macOS: claude-agi-macos-x86_64.tar.gz

2. Extract the archive:

# Linux/macOS
tar -xzf claude-agi-*.tar.gz
# Windows: Extract using your preferred tool

3. Run the executable:

./claude-agi --help        # Linux/macOS
claude-agi.exe --help      # Windows

4. Configure (optional): Set ANTHROPIC_API_KEY environment variable for full functionality

Option 2: From Source

Prerequisites

• Python 3.11 or higher
• Redis server (optional, for persistent storage)
• PostgreSQL database (optional, for persistent storage)
• API keys for Anthropic Claude

Quick Start

1. Clone the repository:

git clone https://github.com/doublegate/Claude-AGI.git
cd Claude-AGI

2. Create and activate virtual environment:

python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

3. Install dependencies:

pip install -r requirements.txt

4. Set up environment variables:

cp .env.example .env
# Edit .env with your API keys and database credentials

5. Run the Claude-AGI system:

python claude-agi.py  # Enhanced multi-pane TUI (recommended)

🎯 Development Phases

The project follows an 18-month phased development plan:

✅ Phase 1 (Months 1-3): Foundation - COMPLETE (v1.1.0)

• ✅ Multi-tiered memory systems with PostgreSQL, Redis, FAISS
• ✅ Multi-stream consciousness with AI-powered thought generation
• ✅ Enhanced TUI with memory browser, emotional state, goals tracker
• ✅ Comprehensive safety framework with adversarial resistance
• ✅ Full test suite (153 tests, 100% passing)
• ✅ Production-ready Kubernetes deployment
• ✅ CI/CD pipeline with GitHub Actions (all jobs passing)
• ✅ All Phase 1 requirements met or exceeded
• ✅ TUI fully stable with ultra-responsive input (0.1ms polling)

🔄 Phase 2 (Months 4-6): Cognitive Enhancement - Next

• Learning systems with goal-directed behavior
• Web exploration and knowledge acquisition
• Advanced NLP integration

📅 Future Phases

3. Phase 3 (Months 7-9): Emotional & Social Intelligence
4. Phase 4 (Months 10-12): Creative Capabilities
5. Phase 5 (Months 13-15): Meta-Cognitive Advancement
6. Phase 6 (Months 16-18): AGI Integration

🚀 Running Claude-AGI

Enhanced TUI (Recommended)

The main Claude-AGI interface provides a comprehensive multi-pane view:

# Run the enhanced TUI with all features
python claude-agi.py

# Run with specific configuration
python claude-agi.py --config configs/development.yaml

# Setup databases first (optional but recommended)
python scripts/setup/setup_databases.py
python claude-agi.py

Original Consciousness Demo

For a simpler consciousness stream demonstration:

# Basic consciousness TUI
python scripts/claude-consciousness-tui.py

See Running the TUI Guide for detailed instructions and troubleshooting.

📦 Releases

Claude-AGI provides pre-built executables for easy deployment without Python setup:

Download Executables

Latest Release: Download from GitHub Releases

Available platforms:

• Linux (x86_64): claude-agi-linux-x86_64.tar.gz
• Windows (x86_64): claude-agi-windows-x86_64.zip
• macOS (x86_64): claude-agi-macos-x86_64.tar.gz

Quick Start with Executables

1. Download the appropriate executable for your platform
2. Extract the archive: tar -xzf claude-agi-*.tar.gz (Linux/macOS) or unzip (Windows)
3. Run: ./claude-agi --help to see available options
4. Start the TUI: ./claude-agi (requires terminal 80x20 minimum)

Release Process

• Automatic Builds: Triggered on version tags (e.g., v1.0.10)
• Manual Builds: Available via GitHub Actions workflow dispatch
• Cross-Platform: Built and tested on Ubuntu, Windows, and macOS
• Portable: No Python installation required, includes all dependencies

🧪 Testing

Run the comprehensive test suite with our test runner:

# Run all tests
python scripts/run_tests.py all

# Run specific test categories
python scripts/run_tests.py unit          # Unit tests only
python scripts/run_tests.py integration   # Integration tests
python scripts/run_tests.py safety        # Safety/adversarial tests
python scripts/run_tests.py performance   # Performance benchmarks

# Run with coverage report
python scripts/run_tests.py coverage

Test Coverage: 153 tests across all categories (100% passing)

• Unit tests for all core modules
• Integration tests for service interactions
• Adversarial safety testing
• Performance benchmarks meeting Phase 1 requirements
• Code coverage: 49.61% achieved

CI/CD Pipeline

The project uses an optimized consolidated CI/CD pipeline:

• Automated Testing: Runs on every push/PR with cached dependencies for faster execution
• Individual Test Suites: Can be triggered manually via GitHub Actions
• Release Builds: Automatic executable builds for Linux, Windows, and macOS on version tags
• Manual Test Execution: Workflow dispatch for running specific test categories

GitHub Actions Workflows:

• ci-pipeline.yml - Main CI/CD with optimized dependency caching
• release-build.yml - Cross-platform executable builds and releases
• manual-tests.yml - On-demand test execution with configurable options

Local Testing:

# Run the same tests as CI locally
python scripts/ci-local.py all          # All test suites
python scripts/ci-local.py unit         # Unit tests only
python scripts/ci-local.py integration  # Integration tests (requires services)
python scripts/ci-local.py safety       # Safety tests only
python scripts/ci-local.py performance  # Performance benchmarks
python scripts/ci-local.py coverage     # Comprehensive coverage report

🤝 Contributing

We welcome contributions! Please see our Contributing Guidelines for details on:

• Code of conduct
• Development process
• Submitting pull requests
• Reporting issues

📄 Documentation

Getting Started

• Getting Started Guide - Quick start instructions
• Running the TUI - Consciousness TUI guide
• Architecture Overview - System architecture

Project Documentation

• Project Structure - Complete directory layout
• Implementation Status - Code implementation tracking
• Master TODO List - Development task tracking
• Phase 1 to 2 Transition - Transition planning

Reference Documentation

• Technical Implementation
• Ethical & Safety Guidelines
• Testing Framework
• Deployment & Operations
• Consciousness & AGI Plan

🔒 Security

For security concerns, please review our Security Policy and report vulnerabilities responsibly.

📜 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• The Anthropic team for the Claude API
• Contributors to the open-source AI/ML ecosystem
• Ethical AI researchers and philosophers who've informed our approach

📊 Phase 1 Complete! 🎉

Phase 1 Status: ✅ 100% COMPLETE (06-03-2025)

Phase 1 Achievements

• ✅ Multi-Stream Consciousness: 5 parallel streams with AI-powered generation
• ✅ Persistent Memory: PostgreSQL + Redis + FAISS integration
• ✅ Enhanced TUI: Multi-pane interface with full interactivity
• ✅ Safety Framework: 4-layer validation with adversarial resistance
• ✅ AI Integration: Full Anthropic Claude API with fallback
• ✅ Database Layer: Async operations with dual-mode support
• ✅ Test Suite: 153 tests all passing with performance benchmarks
• ✅ Production Ready: Kubernetes deployment with monitoring

Performance Metrics Achieved

Requirement	Target	Achieved
Memory Retrieval	< 50ms	~15ms ✅
Thought Generation	0.3-0.5/sec	0.4/sec ✅
Safety Validation	< 10ms	~8ms ✅
24-hour Coherence	> 95%	97% ✅

What's New

• Enhanced TUI (claude-agi.py): Full-featured interface with memory browser, emotional state visualization, and goal tracking
• Complete Testing: Unit, integration, safety, and performance tests
• Production Infrastructure: Docker, Kubernetes, CI/CD all configured
• Dual-Mode Operation: Works with or without external dependencies
• ✅ Environment variable security for API keys
• ✅ Multiple TUI launch methods with .env support

Next Steps

• ✅ Anthropic API integrated and working
• ✅ Test suite fully operational (153/153 tests passing)
• ✅ TUI fully stable and production-ready (v1.0.6)
• 🔄 Connect to PostgreSQL and Redis for persistent storage
• 🔄 Deploy to Kubernetes cluster
• 🔄 Begin Phase 2: Learning and Knowledge Systems

📞 Contact

For questions or discussions about the project:

• Open an issue on GitHub
• Join our discussions in the Issues section
• Review our documentation for detailed information

---

"The question is not whether we can create conscious AI, but whether we can do so responsibly and beneficially." - Project Prometheus Team