Getting Started with Aeion Bridge

The Bridge client runs on your local machine and connects to cloud Aeion OS via outbound WebSocket.

Download:

https://aeionos.com/bridge/download → Windows (.exe installer) → macOS (.dmg) → Linux (.AppImage / .deb)

System requirements:

CPU: x64 or ARM64 RAM: 8 GB minimum (16 GB recommended) GPU: Optional but recommended for AI tasks - NVIDIA GPU with CUDA: 6GB+ VRAM (for Stable Diffusion, TTS) - Apple Silicon: Metal GPU acceleration - CPU-only: supported but slower OS: Windows 10+, macOS 12+, Ubuntu 20.04+ Disk: 10 GB minimum (for AI models) Network: Outbound HTTPS (port 443)

Installation:

```bash # macOS brew install --cask aeion-bridge # OR download .dmg from website

# Windows # Download .exe installer → Run → Follow wizard # Installs to: C:\Program Files\Aeion Bridge\

# Linux sudo dpkg -i aeion-bridge_1.0.0_amd64.deb # OR chmod +x aeion-bridge_1.0.0.AppImage && ./aeion-bridge_1.0.0.AppImage ```

First launch:

1. Open Aeion Bridge 2. Welcome screen: "Connect to Aeion OS" 3. Enter your workspace URL: https://yourcompany.aeionos.com 4. Sign in with your Aeion OS credentials 5. Bridge client authorized → Connected!

Bridge clients authenticate with a signed JWT tied to your tenant and user account — you sign in once from the client, not a separately-issued API key. Each device then advertises what it's actually capable of (GPU compute, Docker, terminal, git, local files, media capture), and you approve which of those capabilities that specific device is allowed to expose to Aeion OS.

Sign in from the Bridge client:

Bridge client → Enter your workspace URL → Sign in with your Aeion OS credentials → Aeion OS issues a signed JWT scoped to your tenant + user → Bridge stores the token locally and uses it for all requests

Approve device capabilities:

``` Admin → Bridge → Devices → John's MacBook Pro

Capabilities detected on this device: ✅ GPU compute (image generation, TTS, video) ✅ Docker (5 containers) ✅ Terminal (shell access) ✅ Git ✅ Local files ✅ Media capture (screen, camera, mic)

Approve → device is authorized to expose these capabilities to Aeion OS ```

Security best practices:

✅ Only approve the capabilities a device actually needs ✅ Revoke a device immediately if it's lost or compromised ✅ Review the Devices list periodically — remove stale entries ❌ Don't approve terminal/shell access on a shared or public machine

Bridge supports local AI models for image generation, TTS, video, and code execution.

Admin → Bridge → AI Models:

``` Available Models:

Image Generation ⬜ FLUX.1 [schnell] — 8GB VRAM — 4 steps, fast ⬜ SDXL Turbo — 6GB VRAM — 1-2 steps, very fast

Text-to-Speech ⬜ Kokoro 82M — 2GB RAM — fast, natural ⬜ XTTS v2 — 4GB RAM — multilingual ⬜ Coqui TTS — 2GB RAM ⬜ Fish Speech — 4GB RAM

Video Generation ⬜ CogVideoX 5B — 12GB VRAM ⬜ Mochi 1 — 24GB VRAM

Audio Generation ⬜ Stable Audio Open — 4GB VRAM

Code Generation ⬜ Qwen3 Coder — local coding model

Code Execution ✅ Node.js 20 (pre-installed) ✅ Python 3.12 (pre-installed) ✅ TypeScript compiler (pre-installed) ```

Install a model:

``` 1. Admin → Bridge → AI Models 2. Click "Install" next to desired model 3. Download starts (FLUX.1 [schnell]: ~5GB) 4. Progress shown in Bridge client 5. "Ready" badge when complete

Installed models persist across Bridge restarts. Models stored in: ~/.aeion-bridge/models/ ```

Local model management via CLI:

```bash # In Bridge client terminal: bridge models list bridge models install flux-schnell bridge models remove sdxl-turbo bridge models update-all

# Check GPU availability: bridge system info # → GPU: NVIDIA RTX 4090, 24GB VRAM, CUDA 12.4 # → Available VRAM: 18GB # → Models that fit: FLUX.1 [schnell], SDXL Turbo, CogVideoX 5B ```

Bridge client auto-discovery:

Bridge client startup: 1. Scan localhost ports for a running Bridge instance (local development) 2. Fall back to your configured Aeion OS URL (production) → Found: WebSocket connection established → Not found: "No Bridge detected" → manual config needed

Bridge separately runs mDNS / WS-Discovery scans on the local network — that's for finding ONVIF cameras and other IoT devices for Sentinel / Smart Spaces integrations, not for the client to find Aeion OS.

Manual configuration:

``` Bridge client → Settings → Connection: Aeion OS URL: https://yourcompany.aeionos.com Signed in as: you@example.com Auto-connect: ✓ Reconnect on disconnect: ✓

Advanced: WebSocket URL: wss://yourcompany.aeionos.com/bridge/ws Timeout: 30s Max retries: 10 ```

Verify connection:

``` Admin → Bridge → Dashboard:

Bridge Status: ✅ Connected — John's MacBook Pro Version: 1.0.4 Last seen: Just now

Capabilities: 🖼️ Image Generation: FLUX.1 [schnell] (ready) 🔊 TTS: Kokoro 82M (ready) 📦 Docker: Connected (5 containers) 💻 Terminal: Approved 📚 Git: Approved 🖥️ Media Capture: Approved

GPU: NVIDIA RTX 4090 — 24GB VRAM — 18GB available Status: Active, 2 models loaded ```

Network requirements:

``` Outbound only (no inbound ports needed): → wss://yourcompany.aeionos.com:443 (HTTPS/WSS)

Firewall: Allow outbound HTTPS (port 443) Works from: Home, office, coffee shop, hotel, VPN Does NOT work from: Networks that block outbound WebSocket ```

From Admin UI:

``` Admin → Bridge → MCP Tools: All available tools listed with descriptions

Search: "image" Results: ✅ compute.image.generate — Generate image from text ✅ compute.image.edit — Inpaint regions of image ✅ compute.image.upscale — Upscale image resolution

Click tool → Form to fill in parameters: Prompt: "futuristic city at sunset, cyberpunk style" Model: FLUX.1 [schnell] Width: 1024 Height: 1024 Steps: 20 → "Generate" button → Result shown: Generated image, metadata, generation time ```

From AI Agent (AeionClaw):

```typescript // AeionClaw can discover and call Bridge tools via MCP:

User: "Generate 4 product photos for our new running shoe" AeionClaw → MCP tools/list → Bridge tools included in response → AeionClaw selects compute.image.generate → Calls tool with parameters → Result returned to user

// What AeionClaw sees: { "name": "compute.image.generate", "description": "Generate images from text prompts using local GPU", "inputSchema": { "type": "object", "properties": { "prompt": { "type": "string" }, "model": { "type": "string", "enum": ["flux-schnell", "sdxl-turbo"] }, "width": { "type": "number" }, "height": { "type": "number" }, "batchSize": { "type": "number", "default": 1 } } } } ```

Use case: Product photography pipeline:

```typescript // User request: "Create hero images for 20 products" AeionClaw processes:

1. For each product (20 total):

1. Save to Aeion Files (module:files)
2. Attach to product record (module:commerce)
3. Notify user: "20 product images generated and saved"

Total time: ~3 minutes (20 products × 2 images × 4s + upscaling) Cost: $0 (local GPU) vs $0.04-0.10/image API = $16-40 for same work ```