Aeion Bridge — Local Hardware + GPU AI for Cloud Aeion OS

Model Context Protocol integration:

```typescript // Bridge MCP tools are standard MCP tools — AI agents discover and invoke them:

// AI agent requests tools: { "method": "tools/list", "params": {} } // Response includes Bridge capabilities: { "tools": [ { "name": "compute.image.generate", "description": "..." }, { "name": "compute.tts.generate", "description": "..." }, { "name": "bridge.docker.list_containers", "description": "..." }, { "name": "bridge.terminal.exec", "description": "..." }, // ... 50+ Bridge tools ] }

// Agent calls a tool: { "method": "tools/call", "params": { "name": "compute.image.generate", "arguments": { "prompt": "futuristic city at sunset", "model": "flux-schnell", "width": 1024, "height": 1024 } } } // → Bridge client receives call // → Executes on local GPU // → Returns image as base64

// Same interface as cloud tools — agent can't tell the difference ```

AI agent workflow with Bridge:

``` User: "Generate product photos for our new shoe line" AeionClaw → Bridge image generation → "flux-schnell" model on local RTX 4090 → 4 images in 8 seconds → Images stored in Aeion Files → Thumbnails generated via Bridge native capture → Results shown in Admin UI

User: "Print shipping labels for today's orders" AeionClaw → Bridge native capture / device tools → Connects to USB label printer → Generates ZPL commands → Prints 50 labels in 30 seconds

User: "Deploy the new Docker container to staging" AeionClaw → Bridge MCP tools (bridge.docker.*) → Remote terminal over WebSocket → docker-compose pull && up → Logs streamed back to Admin UI ```

Every image operation is a Bridge MCP tool call:

```typescript // Text-to-image const result = await bridge.call("compute.image.generate", { prompt: "professional product photography, white background, studio lighting, shoe", negativePrompt: "blurry, watermark, text, logo", model: "flux-schnell", width: 1024, height: 1024, steps: 20, batchSize: 4, // Generate 4 variations });

// img2img const transformed = await bridge.call("compute.image.generate", { prompt: "oil painting style", model: "sdxl-turbo", sourceImage: base64ProductPhoto, strength: 0.75, // 75% influenced by prompt });

// Inpainting const inpainted = await bridge.call("compute.image.edit", { image: base64ProductPhoto, mask: base64Mask, // White = keep, Black = regenerate prompt: "red sports car background", model: "flux-schnell", });

// Upscaling const upscaled = await bridge.call("compute.image.upscale", { image: base64GeneratedImage, scaleFactor: 4, // 1024 → 4096 pixels model: "real-esrgan", });

// Results: { images: [base64String, ...], model: "flux-schnell", generationTime: 8200, // ms seed: 1234567890, steps: 20, cfgScale: 7.5, } ```

Why local vs API (Replicate, OpenAI DALL-E)?

``` DALL-E 3: $0.04/image × 1000/month = $40/month Flux API: $0.003/image × 1000/month = $3/month Local (RTX 4090): $0/image × unlimited = $0/month + $0.15/kWh × 0.05kWh/image × 1000 = $7.50/month electricity + GPU amortized: $0.03/image (3-year RTX 4090)

Local: $0.03-0.04/image equivalent vs $0.003-0.04 API cost At 10K images/month: $300-400 API vs ~$50 local (GPU+electricity) ```

Every TTS operation is a Bridge MCP tool call — parameters: `text` (up to 10,000 characters), `voice`, `model` ("kokoro" / "bark" / "f5-tts"), `speed` (0.5–2.0), `format` ("mp3" / "wav" / "ogg"), `sampleRate`:

```typescript // Generate TTS const audio = await bridge.call("compute.tts.generate", { text: "Your order #12345 has been shipped and will arrive by May 15th.", voice: "en-US-Neural2-F", speed: 1.0, format: "mp3", }); // → Returns: { audio: base64MP3, duration: 3.2, format: "mp3" }

// Stream generation const stream = await bridge.call("compute.tts.stream", { text: "Long form content here...", format: "mp3", }); // → Streams chunks as generated (for real-time applications)

// List available voices const voices = await bridge.call("compute.tts.models", {}); // → [{ id: "en-US-Neural2-F", name: "Female US Neural", language: "en-US" }, ...] ```

Comparison:

ElevenLabs: $0.30/1000 characters = $300/month per 1M chars Google Cloud TTS: $0.016/1000 characters = $16/month per 1M chars Amazon Polly: $0.04/1000 characters = $40/month per 1M chars Local Bridge TTS: $0/character + ~$5/month electricity

Remote terminal over WebSocket:

```typescript // Admin → Bridge → Terminal // → WebSocket connection to Bridge client // → PTY (pseudo-terminal) running on host machine // → Full ANSI color, history, autocomplete

// Code execution via MCP: const result = await bridge.call("bridge.code.execute", { language: "typescript", code: import { z } from "zod"; const schema = z.object({ name: z.string(), age: z.number() }); const result = schema.safeParse({ name: "Alice", age: 30 }); console.log(JSON.stringify(result, null, 2)); , timeout: 10000, // 10 second timeout }); // → { stdout: '{"success":true,"data":{"name":"Alice","age":30}}', stderr: "", exitCode: 0 } ```

Docker management via MCP:

```typescript // List containers const containers = await bridge.call("bridge.docker.list_containers", {}); // [{ id: "abc123", name: "postgres-db", status: "running", image: "postgres:16" }]

// Start / stop / logs await bridge.call("bridge.docker.start_container", { id: "abc123" }); const logs = await bridge.call("bridge.docker.get_logs", { id: "abc123", tail: 100, });

// Docker Compose await bridge.call("bridge.docker.compose_up", { path: "/workspace/docker-compose.yml", }); ```

Git operations via MCP:

```typescript // Clone repository await bridge.call("bridge.git.clone", { url: "https://github.com/acme/backend.git", path: "/workspace/backend", });

// Commit and push await bridge.call("bridge.git.commit", { path: "/workspace/backend", message: "feat: add user authentication", files: ["src/auth/login.ts", "src/auth/logout.ts"], });

// Status and diff const status = await bridge.call("bridge.git.status", { path: "/workspace/backend", }); const diff = await bridge.call("bridge.git.diff", { path: "/workspace/backend", file: "src/auth/login.ts", }); ```

How Bridge connects:

``` Bridge Client (your laptop) ↓ outbound WebSocket (port 443, standard HTTPS) → Cloud Aeion OS API (port 4000)

No inbound ports needed. No port forwarding. No ngrok. No firewall exceptions. Works from home, office, coffee shop, hotel. ```

Authentication:

```typescript // Bridge client authenticates with tenant-scoped API key: { "type": "bridge_client", "tenantId": "tenant_acme_corp", "scopes": ["files:read", "files:write", "docker:manage", "terminal:execute"], "expiresAt": "2027-01-01", "key": "sk_bridge_..." }

// Every MCP tool call validated against scopes: // → compute.image.generate → requires "ai:generate" scope // → bridge.docker.* → requires "docker:manage" scope // → bridge.terminal.exec → requires "terminal:execute" scope ```

Auto-discovery:

```typescript // On startup, Bridge client checks: // 1. localhost:4000 (local development) // 2. Configured bridge URL (production) // 3. mDNS/SSDP discovery (local network)

// Bridge client attempts each discovery method in order // → If found: establishes WebSocket connection // → If not found: operates in cloud-only mode ```