Local skills: fast, quantized models handle classification, semantic search, ranking, OCR, NER, and short-plan generation. These skills expose typed interfaces (inputs, outputs, latency and power budgets, confidence scores) so orchestration remains predictable. 

Orchestrator on-device: a small planner decides which skills to invoke, when to defer to cloud reasoning, and how to apply policies offline. Avoid while‑true prompt loops; use deterministic state machines and guarded retries. 

Memory fabric: short‑term scratchpads for current tasks; session memory summarized to keep prompts lean; persistent vector stores for preferences and recent context. Everything at rest is encrypted with hardware-backed keys. 

Cloud augmentation: long-horizon planning, heavy generation, cross-device reconciliation, and global model updates. The cloud remains the source of truth for identity, policy, and remote configuration. 

Policy mirror: policy‑as‑code compiled into an on-device evaluator so autonomy boundaries hold even offline. Irreversible actions are never executed locally without explicit user ceremony. 

Quantization and distillation: prefer int8 or 4‑bit quantized variants for classification and retrieval; distill larger planners into small task-graph generators for local use. Calibrate per device class (flagship, mid‑tier, low‑tier). 

Speculative/hybrid decoding: for constrained generation (e.g., reply drafts, title suggestions), let the local model draft and the cloud verify when connected. Fall back to local-only with conservative templates. 

Thermal and memory guards: instrument temperature, GPU/NPU utilization, and OOM risks. Segment long jobs into resumable chunks; defer heavy work to charge + Wi‑Fi windows. 

Capability detection: at startup, benchmark a small inference and set per‑device budgets. Use feature flags to disable skills that can’t hit target latency or power envelopes. 

Deterministic state machines: for critical flows checklists, approvals, access control codify allowed transitions and timeouts. Never block key actions on “eventual consistency.” 

Local-first writes: queue intents and record preconditions; reconcile with the server upon reconnect using CRDTs or last‑writer‑wins plus server hints. Surface pending states clearly in the UI. 

Semantic caches: cache by user intent, not blindly. For a field tech, cache next day’s procedures, parts diagrams, and contact trees. For a traveler, cache itinerary details and offline maps for likely detours. 

Hardware-backed keys: encrypt local vector stores and session summaries with keys protected by StrongBox/Secure Enclave. Bind sessions to device attestation; fail safe on root/jailbreak. 

Scoped tools: local tools (camera, files, sensors) are exposed to agents through allowlists and typed adapters. No raw filesystem access; no unbounded bridges. 

Local redaction: redact PII at capture before any cloud call. For OCR of IDs or receipts, run redaction locally and transmit only tokens or summaries. Provide in‑app export/delete that works instantly. 

Provenance: even offline, record signed action receipts (inputs, outputs, policies checked). Upload compressed receipts when reconnected for full audit trails. 

Command chips and palettes: offer one‑tap agent actions predicted from local context (e.g., “Summarize meeting,” “Flag defect with photo”), with previews and clear undo paths. 

Skeletal screens that hydrate: render shells immediately and fill sections as local skills return; later, blend in cloud enrichments without jarring reflows. 

Legible autonomy: show planned steps and what will happen locally vs. in the cloud. Provide sliders for autonomy levels where appropriate. 

Explainability on tap: “Recommended because you saved similar items last month” or “On-device summary generated from your last 30 messages.” Keep it brief and honest. 

Local metrics: per-skill success rates, latency distributions, battery/thermal impact, and fallback counts. Log only aggregates; default to privacy-preserving telemetry. 

Remote config: tune thresholds, disable misbehaving skills, or change model versions over the air with cryptographic signing and staged rollouts. 

Health dashboards: correlate device tier and OS with performance; monitor offline queue backlogs, reconciliation error rates, and policy denials. 

Field service: technicians get step guidance, on-device vision checks for component IDs, and instant defect summaries. Agents queue work orders and reconcile when the van leaves the dead zone. Result: fewer repeat visits, higher first‑time fix rates. 

Retail and commerce: local vector search and re‑ranking make catalogs feel personal without the privacy risk. The cloud handles long-tail discovery. Result: faster discovery, higher conversion, lower inference spend. 

Mobility and logistics: edge agents predict route deviations, detect detours via vision/sensor fusion, and propose micro‑actions without a round trip. Result: steadier ETAs and fewer missed SLAs. 

Productivity: on-device summarization of notes and chats; local intent classification routes tasks to the right lists. Cloud refinement kicks in when connected. Result: calmer UX and better battery life. 

Experience: time‑to‑interaction on cold/warm paths, local skill latency, UI frame stability on inference-heavy screens. 

Reliability: offline task completion and reconciliation success, handoff resilience when networks change, fallback effectiveness. 

Safety and trust: policy denial rates, irreversible action attempts blocked by local mirrors, consent opt-in/out deltas after copy changes. 

Economics: battery minutes consumed per DAU by feature, cloud inference cost avoided, cohort performance by device tier. 

Treating edge as a bolt‑on: dumping a TFLite model into an app without orchestrator, policy mirror, and observability guarantees pain. 

Over‑promising parity: enabling heavy skills on low‑tier devices erodes trust; capability detection must gate features. 

UI spinner traps: blocking core flows on cloud calls defeats the purpose; design for progressive results and offline modes. 

Unscoped bridges: permissive web‑to‑native or tool adapters turn into security incidents. Keep surfaces small and typed.