The watch is the interface. The intelligence lives at the edge.
The Portable Superintelligent Watch Agent Framework solves the hardest problem in wearable AI: frontier cognition stacks cannot run on a watch. The watch has no GPU, no memory bandwidth, no inference capacity for real intelligence.
The solution is architectural. The watch becomes a thin interface layer — a sensor hub, voice portal, and cognition terminal. The actual intelligence lives in a distributed stack: phone as edge orchestrator, Docker containers for portability, Qdrant for semantic memory, LangGraph for agent orchestration, vLLM for scalable inference, and a tool execution mesh that reaches calendar, GPS, health metrics, smart home, finance, and autonomous workflows.
This framework gives you the complete 7-layer architecture: Wearable Interface Layer, Realtime Agent Runtime, Cloud/Edge Orchestrator, Memory + RAG Layer, Inference Router, Tool Execution Mesh, and Knowledge Layer. Every layer is containerized with Docker for portability across local GPU servers, cloud GPU clusters, and hybrid inference networks.
The result: a personal AI companion that knows you, remembers everything, acts proactively, and runs on whatever compute you have — from a $5 Raspberry Pi edge node to a 8xH100 cluster. The watch is just the face. The mind is everywhere.
Full Access Unlocked
All 72 prompts · All 7 modules
"The architectural insight — watch as thin interface, intelligence at the edge — is the only viable p..."
Dr. Kenji Watanabe · Wearable AI Research Lead
Need expert implementation?
Hire an OrchestratorConnect with a certified Prompt.Doctor Orchestrator to deploy this framework for you.
This is frontier architecture. Use Claude Opus for reasoning-heavy stages and GPT-4 for system design stages. Each stage output feeds the next — maintain a running architecture.md document throughout. Final stage builds in Airo.
Experimental Framework — Frontier Architecture
This is a Genius-tier framework. It operates at the frontier of what is currently buildable. Some components are speculative architecture — designed for teams building 2–5 years ahead of the market. Use the prompts to design, prototype, and simulate before committing to full deployment.
Purchase & download the framework
Click the buy button on this page. After checkout, go to the and hit Download .zip. You will get a .md file (all 72 prompts) and a .pdf reference architecture guide. This is dense material — read the PDF in full before running any prompts.
Run Stage 1 in Claude — define your architecture charter
Open the and filter to Stage 1. Run these prompts in Claude (Opus recommended for this tier). Fill every [BRACKET] with your specific context. Stage 1 produces your architecture charter — the foundational document that all subsequent stages build on. Do not skip or rush this step.
Work through Stages 2–6 sequentially — each stage feeds the next
Unlike standard frameworks, Genius-tier stages have hard dependencies. The output of each stage becomes the input context for the next. Keep a running architecture.md document and paste the relevant outputs into each new prompt. Alternate between Claude (for reasoning-heavy stages) and GPT-4 (for system design and schema stages) as indicated in each prompt.
Layer 1: Wearable Interface → Apple Watch / Wear OS thin client (sensor hub + voice portal)
Go to the , filter to Stage 1, and run each prompt with your accumulated context. Output feeds directly into Stage 2.
Layer 2: Phone Edge Node → React Native bridge, edge orchestrator, offline cache, encrypted transport
Go to the , filter to Stage 2, and run each prompt with your accumulated context. Output feeds directly into Stage 3.
Layer 3: Realtime Agent Runtime → LangGraph orchestration + CrewAI + AutoGen + Temporal workflows
Go to the , filter to Stage 3, and run each prompt with your accumulated context. Output feeds directly into Stage 4.
Layer 4: Memory + RAG → Qdrant semantic + Redis realtime + PostgreSQL structured + Neo4j graph
Go to the , filter to Stage 4, and run each prompt with your accumulated context. Output feeds directly into Stage 5.
Layer 5: Inference Router → Local lightweight (Gemma/Phi/TinyLlama) ↔ Cloud heavy (GPT-4o/Claude)
Go to the , filter to Stage 5, and run each prompt with your accumulated context. Output feeds directly into Stage 6.
Layer 6: Tool Execution Mesh → Calendar, GPS, health, smart home, finance, autonomous workflows
Go to the , filter to Stage 6, and run each prompt with your accumulated context. Output feeds directly into Stage 7.
Final Stage — Build the control dashboard in Airo
Go to the and copy the Airo Orchestrator Prompt. Open Airo, start a new project, and paste it into the chat. It will scaffold your complete control dashboard — connecting all the architecture layers you designed in the previous stages into a single operational interface.
7 modules · 72 prompts · 7 workflow stages
Wearable Interface Layer
Apple Watch (WatchConnectivity, Swift bridge, HealthKit, SiriKit) and Wear OS (Kotlin, Wear Compose, Google Health Services) thin client architecture. The watch as sensor hub, voice portal, and cognition terminal.
10 promptsRealtime Agent Runtime
LangGraph for stateful orchestration, CrewAI for multi-role agent collaboration, AutoGen for autonomous task completion, and Temporal for durable long-running workflows. The intelligence core.
12 promptsCloud / Edge Orchestrator
Phone as edge orchestrator, streaming bridge, offline cache, and encrypted transport node. Docker containerization strategy for portability across local GPU, cloud GPU, and hybrid inference networks.
10 promptsMemory + RAG Layer
Qdrant for semantic memory and episodic recall, Redis for realtime agent state, PostgreSQL for structured memory and life logging, Neo4j for relationship graphs. The memory system that makes the agent feel real.
10 promptsInference Router
Lightweight local models (Gemma, Phi, TinyLlama, Qwen small via llama.cpp) for low-latency wearable responses. Heavy cognition routed to local GPU server or cloud cluster via vLLM and Ollama. Latency-aware routing logic.
10 promptsTool Execution Mesh
Agent tool integrations across 12 categories: calendar, GPS/location, reminders, browser, email, smart home, health metrics, finance, workflows, communication, file system, and external APIs. WebSockets + gRPC transport layer.
10 promptsVoice Pipeline + Sensor Fusion
Voice-native pipeline: Whisper/Deepgram STT → Agent reasoning → ElevenLabs/Piper TTS → Watch audio. Sensor fusion: heart rate, GPS, motion, biometrics, environmental data feeding passive cognition and predictive assistance.
10 promptsDesign the complete Wearable Interface Layer for a portable superintelligent agent targeting [APPLE WATCH / WEAR OS / BOTH]. **Core Principle:** The watch is a thin interface. Zero inference on-device. All cognition lives downstream. **Apple Watch Architecture (if applicable):** 1. **WatchConnectivity Session** - Session activation and reachability management - Message passing protocol (sendMessage for realtime, transferUserInfo for background) - File transfer for larger context payloads - Complication data update strategy 2. **Swift Bridge Module** - React Native ↔ Swift native module interface - WatchConnectivity delegate implementation - Background task registration (WKApplicationRefreshBackgroundTask) - HealthKit data streaming (heart rate, HRV, activity, sleep) - SiriKit intent handling for voice activation 3. **Watch UI Design (SwiftUI)** - Minimal interface: status indicator, last agent response, voice trigger button - Complication: ambient agent status (active / thinking / idle) - Haptic feedback patterns for agent responses - Digital Crown interaction for context scrolling **Wear OS Architecture (if applicable):** 1. **Wearable Data Layer API** - DataClient for persistent data sync - MessageClient for realtime communication - ChannelClient for streaming audio - CapabilityClient for feature detection 2. **Kotlin + Wear Compose UI** - Minimal scaffold: agent status, voice button, response card - Tile for ambient display - Google Health Services integration (heart rate, activity recognition) - Complication provider for watch face data 3. **Phone Bridge (React Native)** - Wearable API integration module - Background service for persistent connection - Encrypted local cache for offline responses - Push notification relay from agent to watch **Transport Protocol:** - Watch → Phone: compressed JSON over BLE (< 4KB per message) - Phone → Agent: WebSocket with JWT auth - Response path: Agent → Phone → Watch (< 800ms target latency) **Output:** Complete architecture spec, Swift/Kotlin code scaffolds, React Native bridge module design, and latency optimization checklist.
Design the complete LangGraph agent orchestration system for a portable superintelligent watch agent serving [USER PROFILE / USE CASE]. **Agent Graph Architecture:** ``` User Input (voice/text from watch) ↓ Intent Classifier Node ↓ Router Node → [Quick Response | Deep Reasoning | Tool Use | Memory Retrieval] ↓ [Parallel execution where applicable] ↓ Response Synthesizer Node ↓ TTS Formatter Node → Watch Audio ``` **Node Definitions:** 1. **Intent Classifier** - Input: raw user utterance + sensor context (location, time, heart rate, recent activity) - Output: intent category, urgency score (1–5), required tools[], memory_query_needed - Model: lightweight local (Phi-3 or Gemma-2B) for < 100ms classification 2. **Router Node** - Quick Response path: factual, no tools, cached context → local model - Deep Reasoning path: complex, multi-step → cloud model (GPT-4o / Claude) - Tool Use path: action required → tool execution subgraph - Memory Retrieval path: personal context needed → Qdrant semantic search 3. **Tool Execution Subgraph** - Parallel tool calls where independent - Sequential where dependent - Timeout handling (2s per tool, graceful degradation) - Result aggregation before synthesis 4. **Memory Integration** - Short-term: Redis (last 20 exchanges, current session context) - Semantic: Qdrant (life events, preferences, relationships, knowledge) - Structured: PostgreSQL (calendar, tasks, health history, financial data) - Episodic: timestamped event log for life logging 5. **Response Synthesizer** - Merge tool results + memory context + reasoning - Adapt response length for watch (< 2 sentences) vs phone (full response) - Inject proactive suggestions if confidence > 0.85 - Format for TTS (no markdown, natural speech patterns) **State Schema:** ```python class WatchAgentState(TypedDict): user_id: str session_id: str utterance: str sensor_context: SensorContext intent: IntentClassification memory_context: List[MemoryChunk] tool_results: Dict[str, Any] reasoning_trace: List[str] response: str response_format: Literal["watch_short", "phone_full", "silent_action"] proactive_suggestions: List[str] ``` **Output:** Complete LangGraph graph definition in Python, state schema, node implementations, routing logic, and error handling patterns.
Design the complete Docker containerization strategy for a portable superintelligent watch agent backend. The stack must run identically on: local MacBook (dev), Raspberry Pi 5 (edge), local GPU workstation, cloud VM (AWS/GCP/Railway), and hybrid configurations. **Container Architecture:** ```yaml services: gateway: # Realtime API Gateway (FastAPI + WebSockets) agent: # LangGraph orchestration runtime memory: # Qdrant vector store cache: # Redis realtime state db: # PostgreSQL structured memory embeddings: # Sentence-transformers embedding service inference: # Ollama / llama.cpp local inference worker: # Celery async task workers broker: # NATS message broker ``` **For each container, specify:** 1. **gateway** (FastAPI + WebSockets) - Base image, exposed ports - Environment variables (JWT_SECRET, ALLOWED_ORIGINS, RATE_LIMIT) - Health check endpoint - Volume mounts - Resource limits (CPU/memory per deployment target) 2. **agent** (LangGraph runtime) - Python 3.11 slim base - Dependencies: langgraph, langchain, openai, anthropic, crewai - Environment: MODEL_ROUTER_CONFIG, TOOL_REGISTRY, MEMORY_BACKEND_URL - Scaling: horizontal replica strategy 3. **memory** (Qdrant) - Official qdrant/qdrant image - Persistent volume for vectors - Collection initialization script - Snapshot backup strategy 4. **inference** (Ollama) - GPU passthrough config (NVIDIA runtime) - CPU fallback config (no GPU) - Model preload list: gemma2:2b, phi3:mini, qwen2:1.5b - ARM64 config for Raspberry Pi **Deployment Profiles:** ```yaml # profiles: # dev: gateway, agent, memory, cache, db (no local inference — use cloud) # edge: all services, CPU inference only, resource-constrained limits # gpu: all services, GPU inference, full resource allocation # cloud: gateway, agent, memory, cache, db (inference via API) ``` **Portability Requirements:** - Single `docker-compose.yml` with profile switching - `.env.dev`, `.env.edge`, `.env.gpu`, `.env.cloud` templates - Makefile with: `make dev`, `make edge`, `make gpu`, `make cloud` - Health check script that validates all services before agent startup **Output:** Complete docker-compose.yml, all Dockerfiles, environment templates, Makefile, and deployment guide for each target platform.
architecture
20 prompts
system
22 prompts
workflow
20 prompts
prompts
10 prompts
"The architectural insight — watch as thin interface, intelligence at the edge — is the only viable path for wearable superintelligence. This framework is the first I have seen that gets the compute topology exactly right."
Dr. Kenji Watanabe
Wearable AI Research Lead
"The Docker portability stack is exceptional. Same compose file runs on my MacBook, Raspberry Pi, and GPU workstation with profile switching. The inference router alone saved us 3 months of architecture work."
Priya Nair
AI Infrastructure Engineer
All 72 prompts across 7 modules are unlocked for your account.
Lifetime access