Building an Artificial Cognitive Architecture from Scratch.
BitGenesis is an open-source research project focused on designing and implementing an artificial cognitive architecture entirely from scratch.
Unlike traditional AI assistants based on pre-trained Large Language Models (LLMs), BitGenesis explores the construction of a modular cognitive system where every component is independently designed, implemented, tested and documented.
The long-term vision is to create a transparent and explainable artificial cognitive architecture capable of:
- Perception
- Memory formation
- Knowledge representation
- Reasoning
- Planning
- Learning
- Self-reflection
- Interaction with external systems
BitGenesis is not designed as a chatbot replacement, but as an experimental cognitive software architecture built from first principles.
The primary objectives of BitGenesis are:
- Build an artificial cognitive architecture from scratch.
- Design every subsystem as an independent and replaceable module.
- Create explainable cognitive processes.
- Develop flexible short-term and long-term memory systems.
- Implement event-driven communication between components.
- Create autonomous execution capabilities.
- Enable future learning mechanisms.
- Provide secure interaction with external systems.
- Maintain a fully documented and reproducible architecture.
BitGenesis development follows these principles:
Every subsystem must have a clear responsibility and minimal coupling.
Cognitive decisions should be understandable and traceable.
Components must evolve independently without requiring architectural rewrites.
Predictable behaviour is preferred whenever possible.
Architecture design comes before implementation.
External interactions must happen through controlled boundaries.
Long-term architectural stability is preferred over short-term complexity.
Current version:
v0.2.0
Development stage:
Cognitive Runtime Evolution
BitGenesis has completed the initial foundation milestone and has evolved into a coordinated cognitive runtime architecture.
The current system includes:
- Cognitive Kernel
- Brain lifecycle management
- Runtime execution architecture
- Service orchestration
- Event-driven communication
- Cognitive planning
- Action execution framework
- Runtime metrics
- Runtime statistics
- Runtime snapshots
- Memory subsystem
- Knowledge representation
- Reasoning engine
- Reflection system
- Inference engine
- Dialogue system
The project is now moving toward the Adaptive Intelligence Layer.
Implemented:
- Brain controller
- Lifecycle management
- Configuration system
- Version management
- Runtime statistics
- Core identifiers
Implemented:
- Kernel bootstrap system
- Kernel lifecycle management
- Kernel states
- Service registration
- Service discovery
- Service lifecycle control
- Runtime loop execution
- Runtime coordination
Implemented:
- RuntimeManager
- Cognitive execution pipeline
- Execution plans
- Execution steps
- Planner system
- Planner results
- Executor engine
- Action registry
- Action execution context
- Execution results
- Service orchestration
- Runtime context propagation
Implemented:
- Immutable event model
- Event categories
- Event types
- Event priorities
- Event dispatcher
- Event subscription system
- Event routing
- Category based routing
- Runtime lifecycle events
- Internal communication layer
Implemented:
- Runtime metrics
- Runtime statistics
- Runtime snapshots
- Execution monitoring foundation
- Runtime state inspection
Implemented:
- Memory object model
- Memory storage
- Memory factory
- Memory querying
- Memory retrieval
- Similarity evaluation
- Importance evaluation
- Memory consolidation
- Episode generation
Implemented:
- Entity representation
- Knowledge registry
- Relations
- Knowledge graph foundation
- Knowledge queries
- Inference foundation
Implemented:
- Intent detection
- Resolver system
- Reasoning sessions
- Reflection engine
- Reflection rules
- Inference engine
- Reasoning rules
Implemented:
- Response engine
- Response formatting
- Identity responses
- Memory self-reporting
Current implementation status of the BitGenesis cognitive architecture.
| Component | Status | Description |
|---|---|---|
| Core | ✅ Stable | Brain controller and foundational architecture |
| Kernel | ✅ Stable | Lifecycle, services and runtime loop |
| Event System | ✅ Mature | Event routing and internal communication |
| Runtime | ✅ Mature | Planner, executor and orchestration |
| Runtime Metrics | ✅ Implemented | Runtime monitoring foundation |
| Memory | 🟢 Advanced | Storage, retrieval and consolidation |
| Knowledge | 🟢 Foundation | Entities, relations and graph system |
| Reasoning | 🟢 Functional | Symbolic reasoning components |
| Reflection | 🟢 Implemented | Cognitive evaluation cycle |
| Planning | 🟡 Basic | Initial execution planning |
| Learning | 🔴 Future | Adaptive learning mechanisms |
| Autonomy | 🔴 Future | Autonomous goal management |
| External Tools | 🔴 Future | Controlled external interaction layer |
BitGenesis is currently focused on building the architectural foundations of a modular cognitive system. Advanced capabilities such as learning, autonomy and external tool interaction will be introduced progressively through future milestones.
BitGenesis includes a dedicated functional validation layer separated from the unit testing system.
The purpose of functional tests is validating that the complete architecture works correctly from a user perspective, verifying communication between major subsystems.
Current functional validation coverage:
Functional tests: 9 Status: PASSING
Implemented functional scenarios:
Validates:
- Package availability
- Module exports
- Public API integrity
Example:
BitGenesis import OK
Validates:
- Kernel creation
- Initial state
- Brain initialization
- Lifecycle transitions
- Shutdown process
Example:
Kernel created Kernel started Brain initialized Kernel stopped Kernel Boot Test OK
Validates:
- Service registration
- Service startup
- Runtime execution
- Service ticking
- Service shutdown
Example:
Service registered Kernel running Ticks executed Service state verified Service Lifecycle Test OK
Validates:
- Action registration
- Execution plan creation
- Action execution
- Execution result handling
Example:
Action registered Plan generated Execution completed Cognitive Pipeline Test OK
Validates:
- Decision processing
- Plan generation
- Planner execution flow
Example:
Planner success Generated execution steps Execution completed Cognitive Planner Test OK
Validates:
- Event subscription
- Event publishing
- Category routing
- Listener removal
- Event cleanup
Example:
Subscriber registered Event emitted Routing OK Unsubscribe OK Clear OK Event System Test OK
Validates:
- RuntimeManager creation
- Planner integration
- Executor integration
- Action execution
- Decision execution
Example:
Plan created Execution success Actions executed Runtime Manager Test OK
Validates:
- Kernel
- RuntimeLoop
- ServiceManager
- Services
working together.
Example:
Kernel running RuntimeLoop ticks executed Service ticks executed Kernel stopped Kernel Runtime Integration Test OK
Validates the complete architecture flow:
Kernel | RuntimeLoop | Service Layer | Runtime Manager | Planner | Executor | Action Registry | Event System
Example:
Kernel service registered Kernel started RuntimeLoop ticks executed Runtime action registered Plan generated Cognitive execution completed Kernel stopped BitGenesis Full System Test OK
BitGenesis uses automated testing as a core architectural requirement.
Current status:
515 automated tests passing
Test categories:
- Core tests
- Kernel tests
- Runtime tests
- Memory tests
- Knowledge tests
- Reasoning tests
- Event system tests
- Service lifecycle tests
- Integration tests
- Functional validation tests
Run the complete test suite:
pytest
Development Environment
Recommended:
- Python 3.12+
- Virtual environment
- Editable installation
Install:
git clone https://github.com/bitpredator/BitGenesis.git
cd BitGenesis
pip install -e .
Run tests:
pytest
Repository Structure
Current architecture:
bitgenesis/
│
├── core/
│ ├── brain
│ ├── configuration
│ └── identifiers
│
├── kernel/
│ ├── kernel
│ ├── services
│ ├── runtime_loop
│ └── state
│
├── runtime/
│ ├── execution_plan
│ ├── execution_step
│ ├── planner
│ ├── executor
│ ├── action_registry
│ ├── service_orchestrator
│ ├── runtime_metrics
│ ├── runtime_statistics
│ └── runtime_snapshot
│
├── events/
│ ├── event
│ ├── event_bus
│ └── enums
│
├── memory/
│
├── knowledge/
│
├── reasoning/
│
├── cognition/
│
├── dialogue/
│
├── learning/
│
├── language/
│
├── perception/
│
├── tools/
│
├── security/
│
└── utils/
Additional documentation:
docs/
Roadmap
v0.1.0 — Foundation Release ✅
Status:
Completed
Implemented:
- Core architecture
- Brain lifecycle
- Memory subsystem
- Knowledge foundation
- Reasoning foundation
- Reflection system
- Dialogue system
- Testing infrastructure
v0.2.0 — Cognitive Runtime Evolution 🟢
Status:
In Development
Objective:
Transform BitGenesis from independent cognitive modules into a coordinated cognitive runtime.
Implemented:
- Kernel lifecycle architecture
- Runtime loop
- Service management
- Service discovery
- RuntimeManager
- Cognitive execution pipeline
- Execution plans
- Execution steps
- Planner system
- Executor system
- Action registry
- Runtime metrics
- Runtime statistics
- Runtime snapshots
- Event-driven runtime communication
- Functional validation framework
Remaining focus:
Persistent Memory Architecture
Planned:
- Persistent memory backend
- Memory serialization
- Memory restoration
- Long-term memory management
- Cognitive state persistence
Adaptive Learning Foundation
Planned:
- Experience evaluation
- Feedback processing
- Adaptive rules
- Knowledge reinforcement
- Memory optimization
Runtime Improvements
Planned:
- Runtime lifecycle refinement
- Improved error propagation
- Advanced execution tracing
- Better runtime diagnostics
Architecture Consolidation
Planned:
- API stabilization
- Internal refactoring
- Documentation improvements
- Test suite optimization
v0.3.0 — Adaptive Intelligence Layer
Status:
Future
Objective:
Introduce the first autonomous cognitive capabilities.
Planned:
Advanced Planning
- Multi-step planning
- Dependency aware execution
- Planning strategies
- Dynamic plan adaptation
Goal Management
- Internal goals
- Goal prioritization
- Goal lifecycle
- Goal tracking
Autonomous Execution
- Autonomous task generation
- Task scheduling
- Self-directed execution cycles
- Execution evaluation
Self Evaluation
- Cognitive performance analysis
- Behaviour evaluation
- Runtime self-monitoring
- Improvement suggestions
Knowledge Acquisition
- Dynamic knowledge ingestion
- Knowledge expansion
- Knowledge validation
- Knowledge evolution
Test Architecture Cleanup
Planned:
- Review current test organization
- Merge duplicated tests
- Remove obsolete tests
- Improve test maintainability
- Keep functional tests separated from unit tests
v0.4.0 — Cognitive Expansion
Future objectives:
- Advanced language processing
- Improved contextual understanding
- Multimodal perception foundations
- External environment interaction
- Advanced cognitive interfaces
Contributing
Contributions are welcome.
Before contributing:
1. Read CONTRIBUTING.md
2. Understand the architecture principles
3. Keep changes modular
4. Add tests for new components
5. Update documentation when architecture changes
License
BitGenesis is licensed under the Apache License 2.0.
See:
LICENSE.md
for full details.
Project Vision
BitGenesis explores how an artificial cognitive architecture can be designed from first principles.
The objective is not creating another conversational assistant, but building a transparent cognitive software platform where:
- Memory is explicit.
- Knowledge is structured.
- Reasoning is inspectable.
- Planning is modular.
- Learning can evolve.
- Decisions can be analyzed.
Every subsystem is designed to evolve independently while maintaining architectural transparency.
BitGenesis represents a long-term research platform for exploring artificial cognition through software architecture, engineering discipline and explainable design.