Advanced AGI System

A sophisticated artificial general intelligence system implemented in x86-64 assembly language. The system features advanced neural networks, memory management, decision making, and I/O handling capabilities.

Architecture

The system consists of several key components:

Core Components

Memory Management (memory_manager.asm)

• Hierarchical memory structure (working and long-term)
• Memory block management with priority levels
• Garbage collection and defragmentation
• Memory consolidation and cleanup

Neural Network (neural_network.asm)

• Multi-layer neural network implementation
• Backpropagation and gradient descent
• Activation functions and loss calculations
• Weight optimization

Decision Engine (decision.asm)

• Reinforcement learning capabilities
• Policy and value networks
• Experience replay buffer
• Planning and simulation

I/O Handler (io_handler.asm)

• Multi-modal input/output support
• Stream-based processing
• Efficient buffer management
• Modality-specific handlers

Supporting Components

Math Utilities

• Matrix operations
• Vector calculations
• Statistical functions
• Optimization algorithms

Memory Operations

• Memory block operations
• Data structure management
• Memory alignment
• Cache optimization

Utilities (core/utils.asm)

• System utilities
• Helper functions
• Debugging tools
• Performance monitoring

Building

Prerequisites

• NASM 2.15.05 or later
• GNU Make 4.3 or later
• GNU Linker (ld) 2.38 or later
• GDB 12.1 or later (for debugging)
• Python 3.8+ (for build scripts)

Build Steps

1. Clone the repository:

git clone https://github.com/stix26/agi-system.git
cd agi-system

2. Build the system:

make clean
make all

On macOS, the Makefile automatically switches to Mach-O output when uname reports Darwin. Ensure Xcode command line tools are installed so that ld and clang are available.

3. Run the system:

make run

4. Debug the system:

make debug

Installation

To install the system globally:

sudo make install

To uninstall:

sudo make uninstall

Usage

The system can be used in several ways:

1. Standalone mode:

./build/agi_system

2. Debug mode:

make debug

3. With custom configuration:

./build/agi_system --config config.json

Docker

The repository provides a Dockerfile and a docker-compose.yml for containerized builds. Using Docker ensures the correct toolchain is available and isolates the AGI system from the host environment.

Build the image

docker build -t agi-system .

Run the container

docker run --rm agi-system

Or start the service with Docker Compose:

docker-compose up

Python Integration

Advanced training utilities are provided in the python/ directory. These scripts leverage modern machine learning frameworks to experiment with reinforcement learning and transformer models outside of the core assembly runtime.

Example: PPO Agent

pip install -r requirements.txt
python python/ppo_agent.py

This launches a small PPO trainer for the CartPole environment and prints the episode rewards.

Configuration

The system can be configured through various parameters:

• Memory parameters:

  • Working memory size
  • Long-term memory size
  • Block size
  • Priority levels

• Neural network parameters:

  • Layer sizes
  • Learning rates
  • Activation functions
  • Optimization settings

• Decision parameters:

  • Exploration rate
  • Discount factor
  • Batch size
  • Update frequency

• I/O parameters:

  • Buffer sizes
  • Timeouts
  • Stream configurations
  • Error handling

Development

Adding New Features

1. Create new assembly file in src/core/ directory
2. Add dependencies in Makefile
3. Implement functionality
4. Update main program to integrate new feature

Debugging

1. Use GDB for debugging:

make debug

2. Set breakpoints:

(gdb) break main
(gdb) run

3. Inspect memory:

(gdb) x/10x $rsp

Performance

The system is optimized for:

• Low latency processing
• Efficient memory usage
• Parallel computation
• Real-time response

Project Status

This repository is a proof of concept. Many components are placeholders or stubs intended for experimentation. The current assembly implementation only demonstrates initialization and shutdown sequences. Advanced features described in the documentation are not fully implemented.

Contributing

1. Fork the repository
2. Create feature branch
3. Commit changes
4. Push to branch
5. Create pull request

License

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

Acknowledgments

• Thanks to all contributors
• Inspired by various AGI research
• Built with modern assembly techniques

Contact

For questions and support, please open an issue on GitHub.

SQL Server

A lightweight MySQL server is included via docker-compose. Start the services with:

docker-compose up

This launches the AGI system container alongside a MySQL 8.0 instance. Alternatively, you can start a local server directly:

./tools/start_mysql.sh

After the server is running you can test the connection using:

python python/db_test.py

When finished, stop the server with:

./tools/stop_mysql.sh

Make sure Python dependencies are installed before running the example:

pip install -r requirements.txt