Aideon AI

Autonomous Desktop Agent with Octopus-Inspired Tentacle Architecture

Aideon AI is a cross-platform desktop agent that combines 121+ specialized tentacles, multi-LLM orchestration across 7 providers, hierarchical task planning, zero-trust security, and three-tier memory to autonomously perform complex workflows on your desktop.

Built on Electron with a Node.js backend, Python bridge, and React UI, it runs on Windows, macOS, and Linux.

---

Table of Contents

• Architecture
• Core Systems
  • Tentacle System
  • Multi-LLM Orchestration
  • HTN Planning Engine
  • Memory System
  • Intelligence System
  • Security
  • Distributed Processing
  • Ghost Mode
  • Self-Healing
  • Vision System
• UI
• Browser Extension
• Installation
• Configuration
• Usage
• Testing
• Building
• CI/CD
• Project Structure
• Roadmap
• License

---

Architecture

Aideon uses a six-layer architecture inspired by the distributed neural organization of an octopus, where each tentacle operates semi-autonomously while coordinated by a central brain.

┌──────────────────────────────────────────────────────────────────────┐
│                            Aideon AI                                 │
├──────────────────────────────────────────────────────────────────────┤
│  Layer 6: User Interface                                             │
│  ┌──────────────┬──────────────┬──────────────┬────────────────┐    │
│  │  Electron UI │  Ghost Mode  │    Voice     │ Browser Ext.   │    │
│  └──────────────┴──────────────┴──────────────┴────────────────┘    │
├──────────────────────────────────────────────────────────────────────┤
│  Layer 5: Domain Tentacles (121+ Tentacles, 8 Categories)            │
│  ┌─────────┬──────────┬─────────┬──────────┬──────────┬─────────┐  │
│  │  Comms  │   Prod   │  Dev    │ Finance  │  Intel   │ Special │  │
│  │  (16+)  │  (14+)   │  (5+)   │  (3+)    │  (25+)  │  (12+)  │  │
│  └─────────┴──────────┴─────────┴──────────┴──────────┴─────────┘  │
├──────────────────────────────────────────────────────────────────────┤
│  Layer 4: Cognitive Engine                                           │
│  ┌──────────────┬──────────────┬──────────────┬────────────────┐    │
│  │ HTN Planner  │ Plan Critics │    ARPSM     │  World Model   │    │
│  │  (40 files)  │  (5 critics) │              │                │    │
│  ├──────────────┼──────────────┼──────────────┼────────────────┤    │
│  │ LTM/Memory   │ Knowledge    │ Intelligence │ Metacognition  │    │
│  │  (3-tier)    │   Graph      │  (25 files)  │                │    │
│  └──────────────┴──────────────┴──────────────┴────────────────┘    │
├──────────────────────────────────────────────────────────────────────┤
│  Layer 3: Core Services                                              │
│  ┌──────────┬──────────┬──────────┬──────────┬──────────────────┐   │
│  │  DI/IoC  │ EventBus │ Logging  │ Security │  Self-Healing    │   │
│  │          │          │ Winston  │Zero-Trust│  Circuit Breaker │   │
│  └──────────┴──────────┴──────────┴──────────┴──────────────────┘   │
├──────────────────────────────────────────────────────────────────────┤
│  Layer 2: Tentacle Integration                                       │
│  ┌──────────────┬──────────────────┬──────────────┬─────────────┐   │
│  │   Registry   │  Communication   │  Resources   │   MCP Bus   │   │
│  │              │   Bus (ZT-Sec)   │  Manager     │             │   │
│  └──────────────┴──────────────────┴──────────────┴─────────────┘   │
├──────────────────────────────────────────────────────────────────────┤
│  Layer 1: Platform Foundation                                        │
│  ┌──────────────┬──────────┬──────────────────┬─────────────────┐   │
│  │   Electron   │ Node.js  │  Python Bridge   │  Native Binds   │   │
│  │    v40+      │          │  (ARPSM/LTM/KG)  │  (robotjs)      │   │
│  └──────────────┴──────────┴──────────────────┴─────────────────┘   │
└──────────────────────────────────────────────────────────────────────┘

Architecture Score: 9.2/10 — evaluated across security, resilience, extensibility, performance, and modularity dimensions.

---

Core Systems

Tentacle System

Each tentacle is a self-contained module inheriting from TentacleBase with its own lifecycle, capability registration, and error handling. Tentacles communicate through a zero-trust communication bus.

Tentacle Framework Components:

• TentacleBase / EnhancedTentacle — base classes with lifecycle management
• NeuralRingArchitecture — inter-tentacle neural coordination
• OrchestrationTentacle — workflow orchestration across tentacles
• AGITentacleIntegrationBridge — AGI-level tentacle coordination
• TentacleRegistry — discovery and registration
• TentacleCommunicationBus — secure inter-tentacle messaging
• TentacleResourceManager — shared resource allocation

Multi-LLM Orchestration

The LLMOrchestrator routes tasks to the optimal provider based on task type, cost, latency, and capability requirements.

Key components: LLMOrchestrator, ModelRouter, LocalLlmManager, LLMBenchmarkingService (15 files total)

HTN Planning Engine

A 40-file Hierarchical Task Network planning system that decomposes high-level goals into executable action sequences.

User Goal → HTN Planner → Task Decomposition → Plan Critics → Execution
                ↑                                      │
                └──── Replanning ←── Failure Detection ─┘

• AdaptiveHTNPlanner — ML-enhanced planning with learned heuristics
• HTNOrchestrator — coordinates planner with execution engine
• 5 Plan Critics: Redundant Action, Unnecessary Precondition, Resource Conflict, Safety, Efficiency
• Domain definitions for each tentacle category
• ML integration — learns from successful plans to improve future decompositions
• Replanning strategies — backtrack, replan-from-scratch, partial-repair
• PlanValidator — validates plans before execution

Memory System

Three-tier memory architecture with vector database integration for semantic search.

• VectorDBService — vector similarity search for memory retrieval
• Memory consolidation — transfers short-term to long-term storage
• Association building — links related memories across tiers
• Python bridge for advanced ARPSM/LTM/Knowledge graph operations

Intelligence System

25 files implementing reasoning, learning, and metacognitive capabilities.

• AIIntelligenceCore — central intelligence coordinator
• SuperIntelligenceService / UnifiedAGIService — high-level AGI capabilities
• TemporalReasoningEngine — time-aware reasoning
• AdvancedReasoningEngine — multi-step logical reasoning
• ConsensusEngine — multi-model consensus building
• AdaptiveLearningSystem — learns and adapts from experience
• CuriosityDrivenLearning — explores and learns proactively
• MetacognitionSystem — self-awareness and self-monitoring
• ExplainabilityEngine — generates explanations for decisions
• GoalManagementSystem — autonomous goal setting and tracking

Security

Zero-Trust security architecture (33 files) where every operation is verified regardless of source.

┌─────────────────────────────────────────────────┐
│              Zero-Trust Security Layer            │
│  ┌─────────────────────────────────────────────┐ │
│  │  Cryptographic Identity Verification        │ │
│  │  ┌─────────┐ ┌──────────┐ ┌──────────────┐│ │
│  │  │  ECDH   │ │ AES-256  │ │  Ed25519     ││ │
│  │  │  Key    │ │   GCM    │ │  Signatures  ││ │
│  │  │Exchange │ │Encryption│ │              ││ │
│  │  └─────────┘ └──────────┘ └──────────────┘│ │
│  └─────────────────────────────────────────────┘ │
│  ┌─────────────────────────────────────────────┐ │
│  │  Runtime Protection                          │ │
│  │  Permission System │ Threat Detection        │ │
│  │  Anomaly Detection │ Audit Logging           │ │
│  │  Privacy Manager   │ Encryption Manager      │ │
│  └─────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────┘

• ZeroTrustSecurityManager — central security coordinator
• EnterpriseSecurityManager — enterprise-grade security policies
• SecureCommunication — AES-256-GCM encrypted channels with ECDH key exchange
• PermissionSystem — granular capability-based permissions
• ThreatDetection — real-time threat monitoring
• AnomalyDetectionService — behavioral anomaly detection
• AuditLogService — tamper-evident audit trail
• PrivacyManager — PII detection and data minimization
• Verification framework — multi-layer identity verification

Distributed Processing

13 files enabling multi-node distributed operations.

• DistributedProcessingFramework — coordination layer
• ClusterManager — cluster formation and management
• NodeDiscoveryService — mDNS/UDP multicast discovery with heartbeat monitoring
• LoadBalancer — intelligent work distribution
• ResourceAllocator — resource-aware task placement
• TaskDistributor — parallel task distribution across nodes
• MessageBroker — inter-node messaging
• DistributedCache — shared state across nodes
• ContextSync — synchronized context across distributed nodes

Ghost Mode

Stealth operation mode (13 files) for privacy-sensitive scenarios.

• GhostMode — central stealth coordinator
• ProcessConcealmentManager — hides process from task managers and system monitors
• ScreenBypassManager — evades screen capture and recording
• NetworkStealthManager — minimizes network fingerprint
• StealthAutomationLayer — low-visibility automation execution
• ActivationManager — secure activation/deactivation of ghost mode

Self-Healing

Automatic fault detection and recovery.

• SelfHealingTentacleManager — monitors tentacle health and triggers recovery
• CircuitBreaker — prevents cascading failures with open/half-open/closed states
• Hot-swap — replaces failed tentacles without service interruption
• Fallback strategies — degrades gracefully when components fail
• Predictive failure detection — ML-based early warning system
• LocalHealer — per-tentacle self-repair

Vision System

11 files for screen understanding and visual automation.

• VisionSystemManager — coordinates vision subsystems
• PerceptionEngine — scene understanding from screen content
• OCREngine — text extraction from screen regions (via Tesseract.js)
• MCP integration — Model Context Protocol for vision tasks
• GUI ElementCache — cached element positions for fast interaction

---

UI

97+ React/TypeScript components providing a full desktop interface.

Key surfaces:

• Dashboard — system status, active tentacles, recent activity
• Analytics — performance metrics and usage statistics
• Settings — LLM configuration, security policies, tentacle management
• TaskQueue — task planning, execution monitoring, history
• FileExplorer — integrated file management
• CodeEditor — built-in code editing with syntax highlighting
• Modal system — notifications, confirmations, detail views

Accessibility: Custom hooks for keyboard navigation, screen reader support, and WCAG compliance.

Theming: Dark/light mode with customizable color schemes.

---

Browser Extension

Chrome extension (8 files) that bridges web browsing with the Aideon desktop agent.

• manifest.json — Chrome extension manifest (Manifest V3)
• popup/ — extension popup UI
• background/ — service worker for persistent operations
• content/ — content scripts injected into web pages

Enables web page analysis, form automation, data extraction, and browser-to-agent communication.

---

Installation

Prerequisites

• Node.js 18+ (LTS recommended)
• npm 9+ or yarn 1.22+
• Python 3.10+ (optional, for ARPSM/LTM/Knowledge Graph)
• Git
• Platform-specific build tools for native modules:
  • Windows: Visual Studio Build Tools with C++ workload
  • macOS: Xcode Command Line Tools
  • Linux: build-essential, libx11-dev, libxkbfile-dev

Steps

# Clone the repository
git clone https://github.com/kimhons/Aideon-Final1.git
cd Aideon-Final1/packages/aideon-main

# Install Node.js dependencies
npm install

# Install Python dependencies (optional)
npm run python:install

# Start in development mode
npm run dev

# Or start the Electron app
npm start

Optional: Native Module Dependencies

Some features require optional native modules:

# SQLite for local storage (better-sqlite3)
# Canvas for image processing (canvas)
# RobotJS for desktop automation (robotjs)
# These install automatically if build tools are available

---

Configuration

Create a .env file in the project root:

# LLM API Keys (configure the providers you want to use)
OPENAI_API_KEY=your-openai-key
ANTHROPIC_API_KEY=your-anthropic-key
GOOGLE_API_KEY=your-google-key
TOGETHER_API_KEY=your-together-key
XAI_API_KEY=your-xai-key
AIML_API_KEY=your-aiml-key

# Local Model Settings
OLLAMA_HOST=http://localhost:11434
LOCAL_MODEL=llama2

# Feature Flags
ENABLE_GHOST_MODE=true
ENABLE_LOCAL_MODELS=true
ENABLE_DISTRIBUTED=false

# Security
ENCRYPTION_KEY_ROTATION_HOURS=24
AUDIT_LOG_RETENTION_DAYS=90

Security Configuration

const securityConfig = {
  zeroTrust: {
    verifyAllMessages: true,
    encryptionAlgorithm: 'aes-256-gcm',
    keyExchange: 'ecdh',
    signatureAlgorithm: 'ed25519',
  },
  permissions: {
    defaultPolicy: 'deny',
    requireExplicitGrant: true,
  },
  anomalyDetection: {
    enabled: true,
    sensitivityLevel: 'medium',
  },
};

Self-Healing Configuration

const selfHealingConfig = {
  circuitBreaker: {
    failureThreshold: 5,
    resetTimeout: 30000,
    halfOpenRequests: 3,
  },
  healthCheck: {
    interval: 10000,
    timeout: 5000,
  },
  hotSwap: {
    enabled: true,
    maxRetries: 3,
  },
};

---

Usage

Basic Chat

const response = await aideonAPI.llm.chat('Help me write a Python script');

Execute a Task via Tentacle

const result = await aideonAPI.tentacles.executeTask({
  type: 'code-generate',
  parameters: {
    prompt: 'Create a REST API in Node.js',
    language: 'javascript',
  },
});

HTN Planning

const planner = new AdaptiveHTNPlanner({ domain: 'development' });
const plan = await planner.plan({
  goal: 'deploy-web-application',
  context: { stack: 'node', target: 'aws' },
});
await planner.execute(plan);

Memory Operations

// Store a memory
await aideonAPI.memory.store({
  data: { learned: 'User prefers TypeScript' },
  type: 'semantic',
});

// Retrieve relevant memories
const memories = await aideonAPI.memory.search('user preferences');

Distributed Processing

const framework = new DistributedProcessingFramework();
await framework.initialize();
const nodes = await framework.discoverNodes({ timeout: 5000 });
await framework.distributeTask(heavyTask, { strategy: 'load-balanced' });

Ghost Mode

// Activate stealth operation
await aideonAPI.ghostMode.activate({
  concealProcess: true,
  networkStealth: true,
  screenBypass: true,
});

---

Testing

1,885 tests across 68 suites covering unit, integration, e2e, security, cross-platform, and performance.

# Run all tests
npm test

# Run with coverage report
npm run test:coverage

# Watch mode (development)
npm run test:watch

# Integration tests only
npm run test:integration

# Run a specific test file
npx jest tests/path/to/file.test.js

Test Categories

Test Configuration

• Framework: Jest 29.7.0
• Environment: Node.js
• Timeout: 30s per test
• Max Workers: 2 (prevents SIGTERM issues)
• Memory Limit: 512MB per worker
• Coverage Reporters: text, lcov, html, json

---

Building

Cross-platform builds via electron-builder.

# Build for current platform
npm run build

# Platform-specific builds
npm run build:win      # Windows (NSIS installer, x64)
npm run build:mac      # macOS (DMG, x64 + arm64)
npm run build:linux    # Linux (AppImage + deb, x64)

Build Outputs

---

CI/CD

6 GitHub Actions workflows in .github/workflows/:

---

Project Structure

packages/aideon-main/
├── src/
│   ├── main.js                          # Electron main process entry
│   ├── preload.js                       # Secure context bridge
│   ├── core/                            # (63 files)
│   │   ├── AideonMainApplication.js     # Application bootstrap
│   │   ├── DIContainer.js               # Dependency injection container
│   │   ├── EventBus.js                  # Pub/sub event system
│   │   ├── CircuitBreaker.js            # Fault tolerance
│   │   ├── KnowledgeGraph.js            # Knowledge representation
│   │   ├── Logger.js                    # Structured logging
│   │   └── StateManager.js              # Application state
│   ├── services/                        # (33 files)
│   │   ├── mcp/                         # Model Context Protocol
│   │   ├── auth/                        # Authentication
│   │   ├── context/                     # Context management
│   │   ├── storage/                     # Data persistence
│   │   ├── notification/                # Notification system
│   │   ├── scheduling/                  # Task scheduling
│   │   └── vectordb/                    # Vector database service
│   ├── tentacles/                       # (95+ files)
│   │   ├── base/                        # TentacleBase, EnhancedTentacle
│   │   ├── registry/                    # TentacleRegistry
│   │   ├── communication/               # TentacleCommunicationBus
│   │   ├── resources/                   # TentacleResourceManager
│   │   ├── frameworks/                  # NeuralRing, Orchestration, AGI Bridge
│   │   └── domains/
│   │       ├── communication/           # Email, Social, Meeting, Chat, Voice
│   │       ├── productivity/            # Calendar, Drive, Notes, Tasks, etc.
│   │       ├── development/             # DevMaster, Terminal
│   │       ├── finance/                 # Investment
│   │       ├── intelligence/            # Intelligence tentacle
│   │       ├── security/                # Password management
│   │       ├── specialized/             # Education, CrossDevice, Workforce
│   │       └── gui/                     # ElementCache, OCR
│   ├── llm/                             # (15 files)
│   │   ├── LLMOrchestrator.js           # Multi-LLM routing
│   │   ├── ModelRouter.js               # Provider selection
│   │   ├── LocalLlmManager.js           # Local model management
│   │   ├── LLMBenchmarkingService.js    # Performance benchmarking
│   │   └── providers/
│   │       ├── OpenAIProvider.js
│   │       ├── AnthropicProvider.js
│   │       ├── GoogleProvider.js
│   │       ├── TogetherAIProvider.js
│   │       ├── XAIProvider.js
│   │       ├── AIMLProvider.js
│   │       └── LocalProvider.js
│   ├── planning/                        # (40 files)
│   │   ├── HTNPlanner.js                # Core planner
│   │   ├── AdaptiveHTNPlanner.js        # ML-enhanced planner
│   │   ├── HTNOrchestrator.js           # Plan orchestration
│   │   ├── PlanValidator.js             # Plan validation
│   │   ├── domains/                     # Domain definitions
│   │   ├── critics/                     # 5 plan critics
│   │   ├── ml/                          # ML integration
│   │   └── replanning/                  # Replanning strategies
│   ├── intelligence/                    # (25 files)
│   │   ├── AIIntelligenceCore.js
│   │   ├── SuperIntelligenceService.js
│   │   ├── TemporalReasoningEngine.js
│   │   ├── AdvancedReasoningEngine.js
│   │   ├── MetacognitionSystem.js
│   │   ├── ExplainabilityEngine.js
│   │   └── ...
│   ├── memory/                          # (11 files)
│   │   ├── SemanticKnowledgeBase.js
│   │   ├── EpisodicMemorySystem.js
│   │   ├── ProceduralMemorySystem.js
│   │   └── VectorDBService.js
│   ├── security/                        # (33 files)
│   │   ├── ZeroTrustSecurityManager.js
│   │   ├── SecureCommunication.js
│   │   ├── PermissionSystem.js
│   │   ├── ThreatDetection.js
│   │   ├── AnomalyDetectionService.js
│   │   └── ...
│   ├── distributed/                     # (13 files)
│   │   ├── DistributedProcessingFramework.js
│   │   ├── ClusterManager.js
│   │   ├── NodeDiscoveryService.js
│   │   ├── LoadBalancer.js
│   │   └── ...
│   ├── advanced/                        # (13 files)
│   │   ├── GhostMode.js
│   │   ├── ProcessConcealmentManager.js
│   │   └── ...
│   ├── vision/                          # (11 files)
│   │   ├── VisionSystemManager.js
│   │   ├── PerceptionEngine.js
│   │   └── OCREngine.js
│   ├── config/                          # (9 files)
│   │   ├── ConfigManager.js
│   │   ├── schema/                      # Config validators
│   │   └── environments/                # Per-env configs
│   ├── ui/                              # (97+ files)
│   │   ├── components/                  # React components
│   │   ├── hooks/                       # Custom hooks
│   │   ├── styles/                      # Stylesheets
│   │   └── index.html
│   ├── desktop/                         # (2 files)
│   │   ├── NativePlatformBindings.js
│   │   └── GUIInteraction.js
│   ├── overlays/                        # (4 files)
│   │   ├── OverlayRenderer.js
│   │   └── OverlayManager.js
│   ├── browser-extension/               # (8 files)
│   │   ├── manifest.json
│   │   ├── popup/
│   │   ├── background/
│   │   └── content/
│   └── python/                          # Python bridge
│       ├── bridge.js
│       ├── arpsm/                       # Advanced reasoning
│       ├── ltm/                         # Long-term memory
│       └── knowledge/                   # Knowledge graph
├── tests/                               # (94 files)
│   ├── setup/                           # Test helpers
│   ├── unit/                            # Unit tests
│   ├── integration/                     # Integration tests
│   ├── e2e/                             # End-to-end tests
│   ├── security/                        # Security tests
│   ├── cross-platform/                  # Platform-specific tests
│   ├── performance/                     # Performance benchmarks
│   └── manual/                          # Manual test scripts
├── docs/                                # Documentation
│   ├── ARCHITECTURE.md                  # Detailed architecture docs
│   ├── reports/                         # Analysis and audit reports
│   └── ...
├── .github/workflows/                   # CI/CD pipelines
├── assets/                              # Build assets (icons, images)
├── scripts/                             # Build scripts
├── package.json                         # Dependencies and scripts
├── jest.config.js                       # Test configuration
├── .eslintrc.js                         # Linting rules
├── .prettierrc                          # Formatting rules
├── babel.config.js                      # Babel configuration
└── CHANGELOG.md                         # Version history

---

Roadmap

---

Tech Stack

---

License

MIT License - See LICENSE file for details.

---

Acknowledgments

• Architecture inspired by octopus neural organization, where 2/3 of neurons reside in the arms
• Multi-LLM orchestration inspired by mixture-of-experts approaches
• HTN planning based on hierarchical task network research from AI planning literature
• Zero-trust security model adapted from enterprise security frameworks