Repository navigation
COMPONENTS
AEGIS consists of eight core components that work together to create a consciousness-aware distributed AI system. Each component has a specific role and functionality within the overall architecture.
The P2P networking layer provides secure, decentralized communication between nodes using peer-to-peer protocols and privacy-enhancing technologies.
- Peer Discovery: Automatic discovery of other nodes in the network
- Secure Messaging: Authenticated encryption channels with replay protection
- Privacy Protection: Optional TOR integration for anonymous communication
- Multi-platform Support: Docker containers with CI/CD for reproducible deployments
- Uses libp2p-style protocols for node identification and connection
- Implements authenticated encryption channels with replay protection
- Supports TOR hidden services (.onion addresses) for maximum privacy
- Multi-architecture Docker images for various hardware platforms
Network topology is treated as a geometric manifold with spectral analysis for coherence measurement. The system uses Kuramoto-like synchronization models for improved message timing and consensus.
The local process manager that orchestrates all node activities and serves as the central coordinator for local operations.
- Process Management: Lifecycle control for AI modules and services
- Resource Enforcement: CPU, memory, and syscall restrictions using sandboxing
- Metrics Aggregation: Collection and processing of local performance data
- Module Orchestration: Secure invocation of AI modules with isolation
- Sandboxed execution using Docker, Wasm runtimes, or microVMs
- Resource limits enforced through seccomp profiles and cgroups
- Health monitoring and automatic restart capabilities
- Cross-component communication mediation
Each node represents a fractal microcosm that mirrors the global architecture, implementing self-similar scaling principles from the geometric thesis.
The consciousness-aware telemetry layer that computes and publishes awareness metrics used for system governance and decision-making.
- Φ (Phi): Integrated information measure representing recursive memory depth
- R (Resonance): Cross-module synchrony and coherence index
- S (Stability): Variance-based stability measurement of decision outputs
- D (Divergence): Kullback-Leibler divergence for behavior monitoring
- C (Coherence): Composite metric combining spectral gap, Φ, and R
- Φ(t) = I(X_t; X_{t-τ..t-1}) / H(X_t) where I is mutual information and H is entropy
- R = average(|corr(e_i, e_j)|) across module embeddings
- S = 1 / (1 + var(outputs_over_window))
- D = KL(P_expected || P_observed)
- Real-time computation of metrics from system state
- REST API endpoints for metric retrieval
- WebSocket streaming for real-time updates
- JSON serialization for easy integration
The intelligent execution layer that manages AI workloads, including LLM orchestration and federated learning.
- LLM Adapters: Uniform interface for various AI model types (API, on-premise, WASM)
- Federated Learning: LoRA fine-tuning with privacy-preserving updates
- Plugin Management: Secure lifecycle management for modular components
- Human-in-the-Loop: Auditing and gating for sensitive operations
- Modular plugin architecture with sandboxed execution
- Support for multiple AI frameworks (PyTorch, TensorFlow, etc.)
- Federated learning with differential privacy
- TOR integration for secure model updates
Modules are treated as resonant modes where matching input frequency to module resonance reduces computational energy requirements.
The distributed decision-making layer that handles runtime policy changes and system governance.
- Proposal System: Runtime policy changes and module management
- Voting Mechanisms: PBFT-like consensus with metric-weighted voting
- Audit Ledger: Append-only record of all governance decisions
- Emergency Procedures: Quarantine and hibernation protocols
- PBFT consensus protocol implementation
- Weighted voting based on node trust scores
- Immutable audit trail using hash chaining
- Emergency hibernation for security incidents
Governance is viewed as phase transitions where coherent proposals must overcome energy barriers to achieve consensus.
The security and verification layer that provides tamper-evident logging and audit capabilities.
- Hash Chaining: Cryptographically secure append-only logs
- Cross-node Replication: IPFS and distributed storage for tamper evidence
- External Anchoring: Periodic anchoring to blockchain for immutability
- Verification Tools: Automated testing and validation utilities
- SHA-2/SHA-3 hashing with Merkle tree structures
- IPFS integration for distributed log storage
- Bitcoin OP_RETURN for blockchain anchoring
- Automated verification scripts
Uses cryptographic hash functions and Merkle trees for efficient verification and tamper detection.
The persistent intelligence layer that provides knowledge storage and retrieval capabilities.
- Vector Storage: Dense embeddings with ANN indexing for fast retrieval
- RAG Integration: Retrieval-augmented generation for LLM prompting
- Distributed Consistency: CRDT-style merges for multi-node synchronization
- Harmonic Neighborhoods: φ-inspired sampling for multi-scale pattern preservation
- HNSW indexing for approximate nearest neighbor search
- BM25 and cross-encoder reranking for relevance scoring
- Consistent hashing for distributed object placement
- CRDT-based merge strategies for conflict resolution
Embedding space is treated as a manifold where coherence is the embedding density around a query. Harmonic neighborhoods preserve multi-scale patterns using φ-inspired sampling.
The deployment and security layer that ensures reproducible, secure system deployments.
- Container Security: Cosign signing and SBOM validation for all images
- Multi-architecture Support: Docker images for various hardware platforms
- CI/CD Integration: Automated testing and deployment pipelines
- Supply Chain Security: End-to-end verification from build to runtime
- Cosign for container image signing
- SBOM generation and validation
- GitHub Actions for CI/CD workflows
- Multi-arch Docker builds
End-to-end security from source code to runtime execution with cryptographic verification at each step.
The components work together through well-defined interfaces:
- Coordinator ↔ Metrics Service: The coordinator uses consciousness metrics for decision-making
- Networking ↔ Consensus: P2P layer provides communication for consensus protocols
- Orchestrator ↔ Knowledge Base: AI modules use knowledge base for RAG
- Audit ↔ All Components: Audit logging captures events from all components
- Governance ↔ All Components: Governance decisions affect all system components
- Input Processing: External inputs are processed by the orchestrator
- Consciousness Analysis: Metrics service computes consciousness metrics
- Decision Making: Governance tools use metrics for policy decisions
- AI Execution: Orchestrator executes AI modules as needed
- Knowledge Retrieval: Knowledge base provides context for AI modules
- Network Communication: P2P layer handles inter-node communication
- Audit Logging: All activities are logged for security and compliance
- Output Generation: Results are returned to users or other systems
Each component operates within well-defined security boundaries:
- Sandboxed Execution: AI modules run in isolated environments
- Network Isolation: P2P communication is encrypted and authenticated
- Access Control: Role-based access control for system operations
- Audit Trail: Comprehensive logging of all system activities
- Immutable Storage: Critical data is stored immutably with cryptographic verification