# Resource Comparison: Jarvis AI vs socket.io-computer

## Direct Answer

**socket.io-computer (QEMU VM) takes significantly more resources than Jarvis AI.**

Here's the detailed breakdown:

---

## Component-by-Component Analysis

### Jarvis AI Resource Usage

| Component | RAM | CPU | Disk | Notes |
|-----------|-----|-----|------|-------|
| **FastAPI Server** | 50-100MB | 0.1-0.2 vCPU | ~50MB | Core server |
| **Whisper STT (tiny.en)** | ~273MB | 0.3-0.5 vCPU | ~75MB | Live transcription |
| **Whisper STT (small.en)** | ~460MB | 0.5-1 vCPU | ~460MB | Better accuracy |
| **ElevenLabs TTS** | 50-100MB | 0.1 vCPU | 0 | Cloud service (streaming) |
| **WebSocket Handler** | 20-50MB | 0.1 vCPU | 0 | Per connection |
| **HUD Static Files** | <1MB | 0 | ~1MB | Served from disk |
| **Total (per instance)** | **~400-700MB** | **0.6-1.8 vCPU** | **~500MB** | With small.en model |

**Key Points:**
- STT model is the biggest resource consumer (60-70% of RAM)
- ElevenLabs TTS uses 0 local resources (cloud API)
- CPU usage spikes during transcription, otherwise near-zero
- Can use tiny.en model to reduce RAM by 40%

---

### socket.io-computer Resource Usage

| Component | RAM | CPU | Disk | Notes |
|-----------|-----|-----|------|-------|
| **Node.js Server** | 50-100MB | 0.1-0.2 vCPU | ~20MB | Express + Socket.IO |
| **QEMU Process** | 100-200MB | 0.2-0.5 vCPU | 0 | VM emulation overhead |
| **VM itself (guest)** | **512MB-4GB** | **0.5-2 vCPU** | **5-20GB** | What you assign to VM |
| **Redis (if used)** | 50-100MB | 0.1 vCPU | ~100MB | Optional for state |
| **VNC/WebSocket** | 50-100MB | 0.2-0.5 vCPU | 0 | Frame streaming |
| **Total (per instance)** | **~800MB-4.5GB** | **1-3+ vCPU** | **5-20GB** | Depending on VM OS |

**Key Points:**
- The VM's allocated RAM is the biggest factor (80-90% of total)
- QEMU adds 10-20% overhead on top of VM resources
- CPU overhead: guest using 5% can show as 25-30% on host
- Video streaming adds significant CPU usage during active sessions

---

## Head-to-Head Comparison

### Minimal Configurations

| | Jarvis AI (tiny.en) | socket.io-computer (Linux VM) | Winner |
|---|---|---|---|---|
| **RAM** | ~400MB | ~800MB-1GB | **Jarvis** (2-3x less) |
| **CPU** | ~0.6 vCPU | ~1-1.5 vCPU | **Jarvis** (2x less) |
| **Disk** | ~500MB | ~5-10GB | **Jarvis** (10-20x less) |

### Typical Configurations

| | Jarvis AI (small.en) | socket.io-computer (Windows VM) | Winner |
|---|---|---|---|---|
| **RAM** | ~700MB | ~2-4GB | **Jarvis** (3-6x less) |
| **CPU** | ~1 vCPU | ~2-3 vCPU | **Jarvis** (2-3x less) |
| **Disk** | ~500MB | ~15-20GB | **Jarvis** (30-40x less) |

---

## Why socket.io-computer is More Resource-Intensive

### 1. VM Overhead is Substantial

```
User allocates: 1GB RAM to VM
Actual cost to host: ~1.2GB (VM + QEMU overhead)

User allocates: 2 vCPU to VM  
Actual cost to host: ~2.5 vCPU (VM + emulation + I/O)
```

**Sources:**
- [Server Fault - QEMU/KVM Overhead](https://serverfault.com/questions/1128755/determine-qemu-kvm-overhead)
- Guest shows 5% CPU, host shows 25-30% CPU usage by qemu-system-x86_64

### 2. VM Must Run Full OS

Even a "minimal" Linux VM needs:
- **512MB+ RAM** just for the OS
- **0.5+ vCPU** for basic system tasks
- **2-5GB** disk for OS + apps

Windows needs even more:
- **2-4GB RAM** minimum
- **1-2 vCPU** for decent performance
- **15-20GB** disk for installation

### 3. Video Streaming is Expensive

- Frame capture and encoding: 0.2-0.5 vCPU
- WebSocket streaming: 50-100MB RAM
- Bandwidth: 5-10 Mbps per active user
- Continuous processing while VM is visible

### 4. No Resource Sharing

Each socket.io-computer instance needs:
- Its own QEMU process
- Its own VM
- Its own VNC streaming
- No sharing between users

---

## Resource Breakdown by Component

### Jarvis AI (700MB total)
```
Whisper Model (small.en):  ████████████████████ 460MB (66%)
FastAPI Server:            ████ 100MB (14%)
WebSocket Handler:         ██ 50MB (7%)
Buffers & Processing:      ████ 90MB (13%)
```

### socket.io-computer (2GB minimal VM total)
```
VM (Linux):              ████████████████████████ 512MB (26%)
QEMU Overhead:           █████ 200MB (10%)
VM (actual usage):       ████████████████████ 800MB (40%)
Video Streaming:         ████ 100MB (5%)
Node.js Server:          ████ 100MB (5%)
Reserved/Headroom:       ████████ 300MB (15%)
```

For Windows VM (4GB total):
```
VM (Windows):            ████████████████████████████████████ 2.5GB (62%)
QEMU Overhead:           ████████ 400MB (10%)
Video Streaming:        ████ 100MB (2.5%)
Node.js Server:          ████ 100MB (2.5%)
Reserved/Headroom:       ████████████ 900MB (23%)
```

---

## Real-World Impact

### Scenario: 10 Concurrent Users

**Using Jarvis AI only:**
- Total RAM: ~4-7GB
- Total CPU: 6-18 vCPU
- Total Disk: ~5GB
- **Mostly idle** when users aren't speaking

**Using socket.io-computer only:**
- Total RAM: ~8-45GB (depending on VM size)
- Total CPU: 10-30+ vCPU  
- Total Disk: 50-200GB
- **Constant usage** - VMs run 24/7

**Using both Jarvis AI + socket.io-computer:**
- Total RAM: ~12-52GB per user
- Total CPU: 16-48 vCPU
- Total Disk: 55-205GB

---

## Optimization Implications

### If Resources Are Limited, Prioritize:

1. **Jarvis AI First** - Lower resource cost, higher value
   - Voice interface is unique differentiator
   - Can scale to 10x more users with same hardware
   - Most of the time, users aren't speaking (near-zero resource use)

2. **socket.io-computer Second** - High resource cost, niche use case
   - Only needed for actual desktop/VM use
   - Constant resource consumption
   - Consider container alternatives (95% less resources)

### Alternative: Don't Run socket.io-computer

Instead of running full VMs:

**Use Container-Based Workspaces:**
- Docker containers: 50-200MB vs 512MB-4GB
- xterm.js for terminals (browser-based)
- Still get "computer" feel, 95% less resources

**Use Cloud VM Integration:**
- Don't run VMs at all on your infrastructure
- User brings their own cloud VM
- WakelAI just provides Jarvis voice + control layer
- 0 VM resource cost to you

---

## Conclusion

**socket.io-computer consumes 3-6x more resources than Jarvis AI** for typical configurations.

**Breakdown:**
- **Jarvis AI**: 400-700MB RAM, 0.6-1.8 vCPU (idle most of the time)
- **socket.io-computer**: 800MB-4.5GB RAM, 1-3+ vCPU (constant usage)

**Key Takeaway:** The VM component (socket.io-computer) is your resource bottleneck. Jarvis AI is relatively lightweight by comparison.

**Recommendation:** Focus optimization efforts on socket.io-computer first:
1. Use containers instead of full VMs (95% reduction)
2. Pool VM resources (share when possible)
3. Only allocate resources when users are active
4. Consider bring-your-own-VM model

---

## Sources

- [Whisper Model Sizes Explained](https://openwhispr.com/blog/whisper-model-sizes-explained)
- [faster-whisper GitHub](https://github.com/SYSTRAN/faster-whisper)
- [QEMU/KVM Overhead Discussion](https://serverfault.com/questions/1128755/determine-qemu-kvm-overhead)
- [Socket.IO Memory Usage Docs](https://socket.io/docs/v4/memory-usage/)
- [KVM Overcommitment Guide](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/6/html/virtualization_administration_guide/chap-virtualization-tips_and_tricks-overcommitting_with_kvm)