ONI is a modular repository of neural network components designed to support research and development toward agentic AI systems. It provides a collection of PyTorch modules covering memory, reasoning, attention, emotion modeling, vision, audio, and tool integration—intended as building blocks that researchers and developers can study, adapt, and compose.

Important: ONI is an experimental research project. The modules vary in maturity—some are well-developed implementations, others are prototypes or conceptual sketches but they're being updated continuously. This could be a production-ready AGI system depending on how you configure and train it; it's basically just a toolkit of components that may be useful for building toward more capable AI architectures. Example of how this may be configured can be found in oniQuantum/, oniMini/ and ONI.py. Think legos or bionical or gundam or megazoid. They're made up of interconnected parts that you would consider building blocks. ONI is designed to have atomic modules that can be used in a wide variety of situations depending on how you configure them and their paths.

• Reusable neural modules for memory systems, attention mechanisms, reasoning components, and multimodal processing
• Reference implementations of concepts from cognitive architecture research
• Integration scaffolding for combining modules into larger systems
• Training utilities and example workflows

Memory is one of ONI's more developed areas, offering multiple complementary approaches:

Reasoning modules explore different approaches to structured inference:

Several attention variants for different use cases:

Modules for modeling affective states and ethical reasoning:

Experimental transformer variants and alternative architectures:

Integration utilities for external systems:

ONI includes a Darwin-Gödel Machine-style self-improvement loop that uses ONI's own metacognition to identify weaknesses and apply targeted GRPO training via the Superintelligence Oven.

Key differentiator from vanilla DGM: instead of an external model diagnosing failures, ONI diagnoses itself. As ONI improves, its diagnosis improves — a virtuous cycle.

evaluate → self-diagnose (metacognition) → propose → train (Oven GRPO) → re-evaluate → archive

Parent selection follows DGM's sigmoid-child-proportional algorithm:

P(parent_i) = sigmoid(score_i) × 1/(1 + children_i) / Z

# Test mode — no GPU or model weights required
python -m trainingLoops.train_evolution \
    --archive_dir ./oni_archive \
    --max_generations 5 \
    --verbose

# Full evolution with real model and Oven
pip install -e super_intelligence_oven
python -m trainingLoops.train_evolution \
    --archive_dir ./oni_archive \
    --initial_variant ./ \
    --model_path ./weights/oni_v1.pt \
    --max_generations 80

# Monitor progress
python -m evolution.monitor ./oni_archive

The Superintelligence Oven provides the GRPO training back-end with:

• Hot-swappable local teachers (Qwen3-4B, Qwen3-8B-Q4, diffusion motion)
• Remote agent swarm (critic / adversary / specialist / style / curriculum)
• QwenEmbedVerifier semantic reward (text modalities)
• Per-module teacher routing (ModuleType.ROBOTICS → diffusion teacher, ModuleType.METACOGNITION → big teacher, etc.)

When the oven is not installed, the integration falls back to a mock 10-step SGD pass so the full evolution loop can be validated without external dependencies.

Minimal agent loop examples:

• minimal_recursive_self_directed_loop.py — Basic autonomous task loop
• deep_research.py — Multi-step research workflow
• code_review.py — Automated code review
• github_code_integration.py — GitHub operations

Specialized application modules (varying completeness):

• oni_science_lab.py — Scientific computation utilities
• oni_bioinformatics.py — Bioinformatics tools
• oni_molecular_dynamics.py — Molecular simulation
• oni_quantum_simulator.py — Quantum circuit simulation
• oni_trading_dash.py — Trading dashboard prototype

Experimental distributed training infrastructure:

• Proof-of-Compute consensus for training contribution tracking
• Model update versioning
• Smart contract for contribution rewards (contracts/ONIToken.sol)

Important: The blockchain components are a research prototype simulating proof-of-compute and ledger concepts for AI training coordination. They do not deploy real smart contracts to any live network and do not handle real cryptocurrency or tokens of monetary value. The Solidity contract and Python simulation classes are reference implementations only. Do not use in production financial or governance systems without a full security audit.

git clone https://github.com/ahricat/oni.git
cd oni

# Install dependencies
pip install -r requirements.txt

# Or use the install script
chmod +x scripts/install.sh
./scripts/install.sh

• Python 3.12+
• PyTorch with CUDA support (recommended)
• 16GB+ RAM (48GB+ for full system)
• See requirements.txt for package dependencies

The usage/ directory contains integration examples:

• TkinterChat.ipynb — Simple chat interface
• roboticsController.py — Robot control example
• oni_VRCNPC.cs — Unity VR NPC integration
• unrealNPC.cpp — Unreal Engine NPC

ONI/
├── ONI.py                 # Main model (composes all modules)
├── modules/               # Core neural modules
│   ├── oni_metacognition.py  # Re-export shim (fixes import path)
│   ├── memory/            # Memory systems
│   ├── NLP/               # Reasoning & language (metacognition lives here)
│   ├── attention/         # Attention mechanisms
│   ├── emotion/           # Affective modeling
│   ├── vision/            # Visual processing
│   ├── audio/             # Audio processing
│   ├── dynamics/          # Dynamic layers
│   ├── WorldModel/        # World modeling
│   ├── haptics/           # Tactile systems
│   ├── robotics/          # Robot interfaces
│   └── skills/            # Skill modules
├── evolution/             # ONI-DGM self-improvement system
│   ├── oni_dgm_outer.py   # Main evolution orchestrator
│   ├── oni_self_diagnosis.py
│   ├── oni_archive.py
│   ├── oni_oven_integration.py
│   ├── oni_evaluation.py
│   ├── oni_robotics_trainer.py
│   ├── improvement_proposal.py
│   ├── config.py
│   ├── monitor.py
│   ├── utils/
│   └── tests/
├── prototypellms/         # Experimental architectures
├── tools/                 # External integrations
├── oniapps/               # Domain applications
├── chain/                 # Blockchain prototype (research only)
├── trainingLoops/         # Training scripts incl. train_evolution.py
├── agentWorkflows/        # Agent examples
├── evaluation/            # Module fitness evaluation
├── tests/                 # Test suite
├── usage/                 # Usage examples
├── frontend/              # Web interface
└── scripts/               # Utility scripts

ONI is research software with the following caveats:

• Varying maturity: Some modules are well-tested, others are stubs or prototypes
• Integration gaps: Not all modules compose seamlessly
• Documentation: Inline documentation varies; some modules need more explanation
• Performance: Not optimized for production deployment
• Dependencies: Some modules have specific hardware requirements
• examples of composition see oni.py or all in one models folder to see how you may compose your own onis.

1. Fork the repository
2. Create a feature branch
3. Add tests for new functionality
4. Submit a pull request

ONI draws inspiration from cognitive architecture research, including work on memory consolidation, metacognition, and multi-agent coordination. The compassion framework builds on ideas from AI safety research around value alignment and multi-stakeholder optimization.