Skip to content

04 — Scaling the AI Foundation to ~6 Million Users: Infrastructure & Serving Architecture

Scope. This document specifies the infrastructure/serving foundation that runs Rx360's multiple AI engines — Balance Meter (fall-risk), Smart Scheduling (med reminders), Medication-Input Intelligence (Rx scan → structured object), refill anticipation, and AI triage — at ~6 million older-adult users on frequently poor connectivity. It is an architecture-grade reference: every claim is cited inline, with a consolidated sources list at the end.

Design posture (carried from the rest of the KB). Consumer-wellness lane; clinical intelligence is internal IP. On-device-first for the time-critical + PHI-sensitive path (Balance Meter, scheduling); cloud for training, RAG/KB, and heavy inference. Standards: RxNorm, OpenFDA, FHIR, NCPDP. HIPAA/PHI applies to anything that leaves the device.

0. The scale problem in one paragraph

At 6M users, even rare events are common. If 5% of users generate one assisted interaction per day, that is ~300K interactions/day; if every user's wearable streams gait/balance windows for continuous fall-risk scoring, the time-critical path runs millions of inferences/day and cannot depend on a round-trip to the cloud. The dominant architectural fact is therefore not "how big a GPU fleet do we need" — it is what must never touch the network. Production teams running hybrid edge/cloud LLM systems now route 60–80% of queries to on-device models, cutting latency below ~20ms, eliminating data-residency exposure, and slashing cloud cost (VentureBeat / Perplexity; TianPan, Hybrid Cloud-Edge Architecture). Rx360's senior-user, poor-connectivity profile pushes that ratio higher for the safety-critical engines.

1. The hybrid topology — what runs where, and why

We split the brain into three tiers by a single decision rule: time-criticality × data sensitivity.

Tier A — On-device / edge (the wearable + the phone app)

Runs the time-critical and PHI-sensitive path. This is the non-negotiable tier.

  • Balance Meter (fall-risk from gait/balance). Raw IMU/gait windows are the most PHI-sensitive and most latency-sensitive signal we have. TinyML on the wearable's MCU is the proven pattern: recent quantized fall-detection models hit 98.40% accuracy using ~5 KB RAM and ~40 KB flash, at ~7 ms inference per window (ThinkRobotics), and TinyML fall/gait models run under 1 mW, enabling months-to-years of battery life on a coin cell (Orbitive). Edge processing has been measured to cut response time ~85% vs. cloud analysis (Orbitive) — for a fall, that delta is the product.
  • Smart Scheduling / med reminders. Must fire offline, deterministically. This is local rules + a local notification scheduler, not a model call. The "intelligence" (dose-time optimization, adherence nudging) is computed on-device or pre-computed server-side and cached locally so the reminder itself never needs the network.
  • Medication-Input Intelligence (Rx scan → structured object), first pass. On-device OCR + a small parser handles the common, clean case so the user gets instant feedback in the pharmacy aisle. Hard/ambiguous scans escalate (Tier B/C). On-device LLM runtimes make this feasible: ExecuTorch 1.0 GA (Oct 2025) ships a 50 KB base runtime spanning MCUs to phones (Octomil); INT8 quantization gives 4× compression with acceptable accuracy (Octomil); and current on-device stacks deliver sub-50ms time-to-first-token (e.g., Cactus v1: 136 tok/s on iPhone 17 Pro, 91 tok/s on Galaxy S25 Ultra) (Octomil).

Why edge for this tier: privacy (raw PHI never leaves the device → smaller HIPAA surface), latency (no round-trip), availability (works with zero bars), and cost (edge inference is 20–500× cheaper than the equivalent cloud call: ~$150–$800/month vs. $15K–$75K/month per 1M conversations) (TianPan, Routing).

Tier B — Regional / private-cloud inference ("escalation")

For requests that exceed on-device capability but still involve member context. This is where the larger reasoning model + RAG/KB lives. Apple's shipping precedent is the template: on-device 3B model handles the bulk; when a query exceeds it, it routes to Private Cloud Compute running a larger mixture-of-experts (PT-MoE) model, with a hard guarantee that personal data sent to PCC "isn't accessible to anyone other than the user — not even to Apple" (Apple Security Research; Libertify). For Rx360, Tier B is our equivalent: a HIPAA-eligible private inference environment (BAA-covered) that the device calls only when it must, sending the minimum necessary de-identified or tokenized context.

Tier C — Cloud back-of-house (training, RAG/KB, batch)

Never on the synchronous user path. Hosts: model training/fine-tuning, the versioned medication/clinical KB and vector index (RxNorm/OpenFDA-grounded), batch refill-anticipation scoring, drift/eval pipelines, and the data lake. RAG belongs here because it is the hallucination control: RAG cuts hallucinations 40–71% in document-grounded scenarios, and in a JMIR Cancer medical study GPT-4 + verified RAG sources drove the hallucination rate to 0% (vs. 6% without RAG) (Kernshell).

The routing rule (make it explicit and auditable)

Three signals decide the tier per request (TianPan, Routing): 1. Data-sensitivity routing — PII/PHI/financial bypass cost optimization and stay on the private/on-device tier. This rule wins ties. 2. Task-complexity estimation — a lightweight classifier keeps simple extraction/reformulation on-device; multi-step reasoning escalates. 3. Confidence cascading — the edge model attempts first; outputs below an entropy/confidence threshold escalate to cloud.

Engine Default tier Escalates to Why
Balance Meter (fall-risk) A (wearable TinyML) B (anomaly review only, de-identified) Time-critical + raw PHI; must work offline
Smart Scheduling A (local rules) C (server pre-computes plan, cached to device) Must fire offline, deterministic
Med-Input Intelligence A (OCR/parser) B (hard scans) → C (KB normalize) Instant common case; cloud for ambiguity + RxNorm mapping
Refill anticipation C (batch) — (push result to device) Not interactive; runs nightly
AI triage B (RAG + reasoning model) — Needs grounded KB; never fully on-device

2. Model serving & inference at scale

2.1 Throughput: continuous batching is the single biggest unlock

For the Tier B/C model fleet, continuous (in-flight) batching is mandatory. vLLM with PagedAttention delivers 2–24× throughput over conventional serving, and PagedAttention allows ~4× larger batch sizes on the same hardware by paging the KV cache like OS virtual memory (vLLM Blog; Lyceum). Continuous batching + FP8 on H100 gives 2.3× throughput vs. FP16 static batching (Lyceum). Real proof at our kind of scale: Stripe cut inference cost 73% on 50M daily API calls using 1/3 of its GPU fleet via a vLLM migration (Red Hat).

2.2 Accelerators: don't default to the most expensive GPU

  • AWS Inferentia2 delivers 25–40% lower cost per inference than equivalent GPUs when the model runs on the Neuron SDK, at 2–10 ms LLM latency (inf2 at ~$0.758/hr vs. G5 at ~$1.006/hr) (Wring; Zircon).
  • TPU economics can be transformative at scale: Midjourney moved inference from A100/H100 to TPU v6e and cut monthly spend from $2.1M to under $700K — $16.8M annualized (Ankur's Newsletter).
  • Latency baselines: Inferentia2 ~2–10 ms, TPU Trillium ~5–20 ms, H100 ~10–50 ms per LLM inference step (Pinggy).

Recommendation: standardize Tier B/C on a serving runtime (vLLM/KServe) that is accelerator-portable, then place the steady-state med-input/triage models on Inferentia2 or TPU for cost, keeping a GPU pool for spiky/frontier work.

2.3 Model gateway / router (the cost lever)

Front every model call with a gateway/router. Routing simple queries to small models and hard ones to large models cuts cost 40–70% (Lushbinary). Use an open, self-hostable gateway (LiteLLM / Helicone) for auditable routing logic, unified spend tracking, and provider portability — avoiding the 5% markup of managed routers like OpenRouter (Helicone). The gateway is also where we attach the fallback chain (§5) and the spend circuit breaker (§4).

2.4 LLM-API vs. self-hosted (cost/latency/control)

  • Break-even: self-hosting beats premium APIs around 5–10M tokens/month; for budget APIs you need 50–100M tokens/month to justify the ops overhead (AISuperior). A 13B model reaches cost parity with GPT-4-turbo at only ~10% utilization; a 7B needs ~50% utilization to beat GPT-3.5-class pricing; the operational crossover is >8,000 conversations/day (Introl, Unit Economics).
  • Control/compliance: for PHI-adjacent triage, self-hosting in a BAA-covered environment removes a third-party data-sharing surface — a compliance argument that often outweighs marginal cost.

2.5 Small-model + retrieval vs. large-model — and cost-per-query at millions/day

The economically correct default is small model + RAG, escalating only on low confidence. 70–80% of production LLM queries never need a frontier model (TianPan, Hybrid Cloud-Edge Inference). Worked cost-per-query (from Introl, Unit Economics):

  • At commodity inference pricing (~$0.40/M tokens, ~100 output tokens/query): ~$0.00004/query → ~$40/day for 1M queries → ~$1,200/month.
  • Self-hosted at ~$12/hr (8 GPUs, overhead-amortized) at break-even volume ≈ $5,040/month, i.e., self-host only pays once volume and utilization are high.
  • Optimizations compound: quantization (4×) × continuous batching (2×) × speculative decoding (2×) ≈ 16× effective cost reduction (Introl, Unit Economics).

Rx360 implication: with most interactions handled on-device (Tier A, ~$0 marginal) and RAG-grounded small models for Tier B, the cloud cost-per-query is dominated by the RAG context payload, not the model — which makes caching (§3) a financial requirement, not an optimization.

3. Caching & latency budgets

3.1 Semantic caching of LLM/RAG responses

Older adults ask the same things ("when do I take my blood pressure pill?", "can I take this with food?"). Semantic caching returns a stored answer when a new query's embedding is "close enough" (cosine similarity, typical threshold ~0.8) to a cached one (DEV / Kuldeep Paul). Measured impact: - GPT Semantic Cache: API calls reduced up to 68.8%, cache hit rates 61.6–68.8%, with positive-hit accuracy 92.5–97.3% — backed by Redis in-memory storage + HNSW similarity search (O(n)→~O(log n)) (arXiv 2411.05276). - Industry baseline: ~31% of LLM queries are semantically similar — pure waste without caching (DEV / Kuldeep Paul). - Prefix/prompt caching (provider-native) adds ~90% cost / ~85% latency reduction on long prompts (Anthropic) and ~50% cost savings (OpenAI automatic caching) — directly relevant because RAG inflates a 50-token question into a 4,000-token payload (an 80× overhead sent on every call) (Introl, Prompt Caching).

Cache layers for Rx360: (1) on-device answer cache for the top FAQ/med questions (works offline); (2) regional semantic cache (Redis + HNSW) in front of Tier B; (3) provider prefix-cache for the static RAG/KB context block. Every cache entry is keyed to the KB version (§6) and a conservative similarity threshold for any medication-safety answer, with a TTL so KB updates invalidate stale clinical content.

3.2 Latency budgets per interaction

Interaction Path Target Basis
Fall-risk scoring On-device TinyML ~7 ms/window ThinkRobotics
Med reminder fire On-device scheduler instant, offline offline-first (Locize)
Rx scan parse (common) On-device LLM <50 ms TTFT Octomil
Cached Q&A Semantic cache low ms (no model call) Introl, Prompt Caching
Triage / hard scan Tier B (cloud) ~350–400 ms + network TianPan, Routing

4. Multi-tenancy, per-member partitioning & horizontal scaling

Each member is a tenant of one (their own PHI). Pattern selection for HIPAA at 6M-member scale (Knowi; Nirmitee):

  • Row-level security (RLS) enforced at the query layer, not the UI, with a member_id on every PHI table, so no member's PHI can ever surface in another's context. RLS scales to thousands–millions of tenants (Knowi).
  • Encryption is mandatory: AES-256 at rest, TLS 1.2/1.3 in transit (Knowi).
  • Silo (DB-per-tenant) produces the cleanest HIPAA audit evidence but doesn't scale to 6M individuals — reserve it for B2B2C accounts (a partnering clinic/payer), with RLS for the individual members inside (Askantech).
  • Sharding by member_id for horizontal scale; isolation also defeats the "noisy neighbor" problem where one heavy tenant degrades everyone (Redis).

Horizontal scaling of the serving layer. Stateless inference pods behind the gateway, autoscaled by KEDA on queue depth / GPU load — not CPU, which is meaningless for GPU pods (Markaicode); Karpenter scales the underlying GPU nodes; predictive autoscaling (e.g., Prophet) pre-warms capacity ahead of the predictable morning med-reminder/refill spike (Kedify). Attach a cost circuit breaker: an uncapped spike scaled one deployment to 40 GPU pods and $12,000 in 6 hours, where a KEDA cost guard would have capped it at ~$800 (Markaicode).

5. Reliability / SLAs — offline mode, graceful degradation, deterministic fallback

For a senior-safety product, degradation must be predictable, not best-effort. "Graceful degradation means the system behaves predictably, communicates clearly, and avoids cascading damage" (iLoveDevOps).

  • Offline-first by construction. Data is stored locally first; the app works on unstable/absent networks; sync resumes in the background (Locize). The safety-critical engines (Balance Meter, Smart Scheduling) never depend on the network for their core function.
  • Deterministic fallback for the safety path. When the model/network is unavailable, fall back to deterministic behavior: rules-based reminders still fire; fall detection still scores locally; "you should still be able to triage even if the AI piece is offline" (GitHub Blog).
  • Fallback chain at the gateway. Primary model → cheaper same-provider model → different provider → self-hosted local model (no external dependency) (iLoveDevOps).
  • Circuit breakers that trip on quality, not just errors. States CLOSED → OPEN (fail fast / route to fallback) → HALF-OPEN (probe recovery); for LLMs, also trip on quality degradation, not only outages (iLoveDevOps).
  • Communicate the degraded state. When triage is running in deterministic/cached mode, the UI says so — a senior user must never be silently given a stale or lower-confidence answer on a medication question.

6. Observability & monitoring at scale

Standardize on OpenTelemetry GenAI Semantic Conventions — the emerging standard schema for prompts, responses, token usage, tool/agent calls, and provider metadata — to unify app, infra, and AI telemetry (OpenTelemetry; Datadog). This is becoming table stakes: Gartner projects LLM-observability spend reaches 50% of GenAI deployments by 2028 (up from 15% in early 2026) (Confident AI).

Log the decision context for every AI decision (essential for a regulated, safety-adjacent product): - Full execution tree per call — system prompt → retrieval → response, with inputs/outputs/duration/token counts (OpenObserve). - Which KB entry + version grounded the answer, which rail/guardrail verdict fired, which tier served it, and cache hit/miss. (RAG with versioned KB is what lets us reconstruct why the system said what it said — and is the same mechanism that drove the medical hallucination rate to 0% in §1.) - Cross-turn analysis, not per-request: most real failures are context drift, escalating hallucination, and tool-selection breakdown that only appear across turns (Greptime).

Dashboards: (1) drift — eval on production traces at the prompt/use-case level (Greptime); (2) cost — per-tier, per-engine spend via the gateway, with the circuit-breaker state visible; (3) latency — p50/p95/p99 against the §3.2 budgets; (4) RAG quality SLOs — Faithfulness >0.9, Answer Relevancy >0.85, Context Precision >0.8 (Lushbinary, RAG Production).

7. Real precedents — consumer-health / AI at millions of users

  • Apple Intelligence + Private Cloud Compute (billion-device scale). The canonical hybrid: on-device small model handles most queries; escalation routes to a privacy-guaranteed cloud (PCC) running a larger MoE — with a cryptographic guarantee that user data "isn't accessible to anyone other than the user — not even to Apple." This is the exact privacy-tiered topology Rx360 needs for PHI (Apple Security Research; Libertify).
  • Stripe — 50M daily API calls. vLLM migration cut inference cost 73% on 1/3 of the GPU fleet — proof that continuous batching is the dominant cost lever at high request volume (Red Hat).
  • Midjourney — accelerator swap. A100/H100 → TPU v6e cut inference spend from $2.1M/mo to <$700K/mo (Ankur's Newsletter).
  • Ada Health — symptom-assessment at scale. 12M+ users across 130+ countries, with every symptom pathway physician-reviewed before launch — a consumer-health precedent for clinically-governed AI in the consumer lane (TechCrunch).
  • Noom — 45M+ downloads. Demonstrates the consumer-health stack (React Native + Python/PostgreSQL + TensorFlow/PyTorch serving on HIPAA-configured cloud) at multi-tens-of-millions scale (Biz4Group).
  • Amazon used vLLM continuous batching in a multinode architecture so token volume didn't degrade latency — the spike-resilience pattern behind §4 (Red Hat).

8. Reference architecture (summary)

WEARABLE (Tier A)                 PHONE APP (Tier A)              PRIVATE CLOUD (Tier B/C)
─────────────────                 ──────────────────             ────────────────────────
Balance Meter TinyML              On-device OCR/parser            Model Gateway/Router (LiteLLM)
  ~7ms, <1mW, offline      ──┐    Local scheduler (offline)        ├─ semantic cache (Redis+HNSW)
Local fall rules            │    On-device small LLM              ├─ prefix cache (static KB ctx)
                           │    On-device answer cache           ├─ vLLM/KServe + PagedAttention
   anomaly only,           │      (top FAQs, offline)            │    on Inferentia2 / TPU / GPU
   de-identified ──────────┴──────────── escalate (PHI-min) ───► ├─ RAG over versioned KB
                                                                 │    (RxNorm/OpenFDA/FHIR/NCPDP)
   ROUTING: sensitivity > complexity > confidence-cascade        ├─ KEDA(queue) + Karpenter + $-guard
                                                                 └─ Tier C: training, batch refill,
   FALLBACK: primary→cheaper→other provider→local model              drift/eval, data lake
   DEGRADE: deterministic rules always available offline

OBSERVABILITY (cross-cutting): OpenTelemetry GenAI traces → {KB entry+version, rail verdict,
tier, cache hit} → dashboards: drift | cost/tier | p50/p95/p99 latency | RAG SLOs
MULTI-TENANCY: member = tenant; RLS at query layer; AES-256/TLS; shard by member_id;
              silo only for B2B2C clinic/payer accounts

Three rules to defend in any review: 1. PHI/time-critical never depends on the network. Edge-first is a safety and compliance decision before it is a performance one. 2. Small-model + RAG by default; escalate on confidence. 70–80% of queries don't need a frontier model; caching makes the rest affordable. 3. Degrade deterministically and say so. A senior user always gets a correct, safe behavior — and is told when the AI layer is degraded.

Sources

  • ThinkRobotics — TinyML on microcontrollers (fall detection: 98.4% acc, ~5KB RAM, ~7ms): https://thinkrobotics.com/blogs/learn/tinyml-applications-on-microcontrollers-revolutionizing-edge-ai
  • Orbitive — TinyML at the edge (<1mW, ~85% latency cut vs cloud): https://orbitive.tech/blog/tinyml-at-the-edge-privacy-preserving-energy-efficient-on-device-ai-for-wearables-and-mobile
  • Octomil — On-Device LLM Inference 2025–2026 (ExecuTorch 1.0, INT8 4×, sub-50ms TTFT): https://docs.octomil.com/blog/on-device-llm-inference-2025-2026/
  • vLLM Blog — Anatomy of a High-Throughput Inference System (PagedAttention, 2–24×): https://blog.vllm.ai/2025/09/05/anatomy-of-vllm.html
  • Lyceum — LLM Inference Batching Strategies (continuous batching, FP8 2.3×): https://lyceum.technology/magazine/batching-strategies-llm-inference-throughput/
  • Red Hat — How vLLM accelerates inference (Stripe 73%, Amazon multinode): https://www.redhat.com/en/topics/ai/how-vllm-accelerates-ai-inference-3-enterprise-use-cases
  • Wring — AWS Inferentia vs GPU pricing (25–40% lower cost): https://www.wring.co/blog/aws-inferentia-vs-gpu-pricing
  • Zircon — Inferentia2 vs Trainium vs GPU for production: https://zircon.tech/blog/aws-ai-infrastructure-inferentia2-vs-trainium-vs-gpu-for-production-workloads/
  • Pinggy — Fastest AI inference hardware 2026 (latency baselines): https://pinggy.io/blog/fastest_ai_inference_hardware/
  • Ankur's Newsletter — TPUs vs Trainium/Inferentia vs GPUs (Midjourney $2.1M→<$700K): https://www.ankursnewsletter.com/p/google-tpus-vs-aws-trainium-and-inferentia
  • Lushbinary — LLM Gateway & Model Routing (40–70% cost cut): https://lushbinary.com/blog/llm-gateway-model-routing-cost-optimization-guide/
  • Lushbinary — RAG Production Guide 2026 (Faithfulness/Relevancy/Precision SLOs): https://lushbinary.com/blog/rag-retrieval-augmented-generation-production-guide/
  • Helicone — Top LLM Gateways 2025 (LiteLLM/Helicone self-host; OpenRouter 5% markup): https://www.helicone.ai/blog/top-llm-gateways-comparison-2025
  • AISuperior — LLM Hosting Cost (self-host vs API break-even): https://aisuperior.com/llm-hosting-cost/
  • Introl — Inference Unit Economics: True Cost per Million Tokens (cost-per-query math, 16× compounding): https://introl.com/blog/inference-unit-economics-true-cost-per-million-tokens-guide
  • Introl — Prompt Caching Infrastructure (Anthropic 90%/85%, OpenAI 50%, 80× RAG overhead): https://introl.com/blog/prompt-caching-infrastructure-llm-cost-latency-reduction-guide-2025
  • arXiv 2411.05276 — GPT Semantic Cache (68.8% API reduction, Redis+HNSW, 0.8 cosine): https://arxiv.org/html/2411.05276v3
  • DEV / Kuldeep Paul — Reducing LLM cost & latency with semantic caching (31% similar queries): https://dev.to/kuldeep_paul/reducing-llm-cost-and-latency-using-semantic-caching-3bn9
  • Kernshell — How RAG reduces hallucinations (40–71%; JMIR 6%→0%): https://www.kernshell.com/how-rag-reduces-ai-hallucinations-and-improves-accuracy/
  • Knowi — Multi-tenant analytics for healthcare SaaS (RLS, AES-256/TLS): https://www.knowi.com/blog/multi-tenant-analytics-healthcare-saas/
  • Nirmitee — Multi-tenant architecture for healthcare SaaS: https://nirmitee.io/blog/multi-tenant-architecture-healthcare-saas/
  • Askantech — Multi-tenant SaaS isolation, scale, compliance (silo model): https://www.askantech.com/multi-tenant-saas-architecture-isolation-scale-compliance/
  • Redis — Data isolation in multi-tenant SaaS (noisy neighbor): https://redis.io/blog/data-isolation-multi-tenant-saas/
  • Markaicode — Auto-scaling GPU inference on Kubernetes (KEDA queue depth, $12K/6h cost guard): https://markaicode.com/auto-scaling-gpu-inference-kubernetes/
  • Kedify — Predictive autoscaling for Kubernetes (Prophet pre-warming): https://kedify.io/resources/blog/predictive-autoscaling/
  • iLoveDevOps — Graceful degradation when models are unavailable (fallback chain, circuit breakers): https://ilovedevops.substack.com/p/graceful-degradation-when-models
  • Locize — Offline-first apps architecture: https://www.locize.com/blog/offline-first-apps/
  • GitHub Blog — AI issue triage with Copilot SDK (degrade gracefully): https://github.blog/ai-and-ml/github-copilot/building-ai-powered-github-issue-triage-with-the-copilot-sdk/
  • OpenTelemetry — GenAI Observability (2026): https://opentelemetry.io/blog/2026/genai-observability/
  • Datadog — LLM Observability + OTel GenAI Semantic Conventions: https://www.datadoghq.com/blog/llm-otel-semantic-convention/
  • Confident AI — Top LLM Observability Tools (Gartner 50% by 2028): https://www.confident-ai.com/knowledge-base/compare/top-7-llm-observability-tools
  • Greptime — Agent Observability (cross-turn failure modes): https://www.greptime.com/blogs/2025-12-11-agent-observability
  • OpenObserve — LLM Observability (full execution tree): https://openobserve.ai/llm-observability/
  • TianPan — Hybrid Cloud-Edge LLM Architecture: Routing Inference (sensitivity/complexity/confidence; 20–500× cost): https://tianpan.co/blog/2026-04-10-hybrid-cloud-edge-llm-architecture-routing-inference
  • TianPan — Hybrid Cloud-Edge LLM Inference: When On-Device Beats Cloud (70–80% don't need frontier): https://tianpan.co/blog/2026-04-10-hybrid-cloud-edge-llm-inference-when-to-run-on-device
  • VentureBeat — Perplexity hybrid local-cloud inference (60–80% on-device): https://venturebeat.com/technology/perplexity-ai-unveils-hybrid-local-cloud-inference-system-at-computex-2026
  • Apple Security Research — Private Cloud Compute: https://security.apple.com/blog/private-cloud-compute/
  • Libertify — Apple Intelligence Foundation Models 2025 (on-device 3B + PT-MoE PCC routing): https://www.libertify.com/interactive-library/apple-intelligence-foundation-models-2025/
  • TechCrunch — Ada Health Series B (12M+ users, 130+ countries, physician-reviewed): https://techcrunch.com/2021/05/27/ada-health-closes-90m-series-b-led-by-leaps-by-bayer/
  • Biz4Group — Build an AI health app like Noom (45M+ downloads; consumer-health stack): https://www.biz4group.com/blog/build-ai-health-management-app-like-noom