Logo

HealthGuard — Decentralized Private AI Health Agent

Built On Akash. Powered By Venice. Private By Design.

WEBSITE : http://j89it0b9ip8nb63nm12be34k7s.ingress.boogle.cloud/

Hook

One breach can expose a million patients. One cloud holds every photo, every voice note. HealthGuard doesn’t hold them. We run on decentralized compute, use AI that forgets the moment it’s done, and store only what’s encrypted. Same vigilance. Zero retention.

What We Built

A 24/7 autonomous health agent that monitors patient vitals, analyzes wound photos, transcribes voice notes, detects dangerous patterns, and alerts doctors automatically — then forgets everything the moment it is done.

Flow:

Patient Input → Venice (perceive + forget) → AkashML (reason) → Decision Engine → Encrypted SQLite on Akash

Ingestion: EXIF stripped, ephemeral session IDs, 60s TTL on raw files.
Venice: STT (voice → text), Vision (photo → clinical JSON), TTS (alerts → spoken), Image Gen (summaries → visual reports). Raw data deleted immediately after each call.
AkashML: SOAP notes, clinical triage, anomaly detection, loop decisions — on structured text only. No raw photos, audio, or patient names ever sent.
Decision engine: Rules first (e.g. BP ≥ 180 → critical), then AI. Rules always win.
Delivery: Telegram + Venice TTS for alerts; encrypted SQLite on Akash for state; append-only audit log for every action.

Sponsor Tools — Used Fully

Akash Network

We run the entire application on Akash. No fallback to AWS, GCP, or Azure anywhere.

Use	How We Use Akash
Deployment	Full stack deployed via Akash Console using our SDL. Single service: FastAPI gateway + agent loop + cleanup worker.
Compute	4 vCPU, 8 Gi memory. Agent loop runs 24/7 on Akash providers — processes event queue every 60s, runs periodic AkashML checks, cleans ephemeral files.
Persistence	Persistent volume at `/data` (10 Gi, class `beta3`). SQLite DB and audit log live here. State survives redeploys and container restarts.
Reasoning	AkashML API (OpenAI-compatible) for clinical reasoning: SOAP notes, triage, anomaly detection, patient briefings, doctor reports. Base URL: `https://chatapi.akash.network/api/v1` or `https://api.akashml.com/v1`; we call `POST /chat/completions`. We never send PHI — only transcripts, vision JSON, and anonymized vitals.
Public access	Service exposed on port 80 (mapped from 8080). Live URL from Akash Console at submission.

Why Akash is essential: Decentralized compute means no single vendor holds our keys or our data. The provider sees a running container and an encrypted volume. Patient data is encrypted at rest (AES-256-GCM); even if the disk were copied, it would be unreadable without the derived key. We get production-grade uptime and persistence without locking into a centralized cloud.

Venice AI — All 4 Endpoints

Base URL: https://api.venice.ai/api/v1 (OpenAI-compatible)

Every patient-facing input is PHI. Venice’s zero-retention architecture is the only way we can use commercial-grade models without creating a HIPAA liability. We use all four Venice endpoints in production:

Model	API Path	What We Do With It
Whisper Large V3	`POST /audio/transcriptions`	Patient voice notes → transcript. Audio is sent, transcribed, then deleted. We never store raw audio.
Qwen3-VL 235B	`POST /chat/completions` (vision)	Wound/skin/medication photos → structured JSON (observations, severity, infection risk, patient summary). Image is sent, analyzed, then deleted. We never store raw images.
Kokoro (54 voices)	`POST /audio/speech`	Critical and warning alerts → spoken audio for the patient. Especially important for elderly or low-literacy users. Audio is generated and streamed; Venice does not retain the health content.
Flux (Image Gen)	`POST /images/generations`	Weekly visual health report cards from encrypted text summaries only. No raw PHI is sent; the prompt is derived from already-anonymized summaries.

Why Venice is the only inference provider that makes this possible:
Any provider that retains data creates a breach surface and BAA obligations. Venice’s zero retention is architectural — there is no database of your inputs because they are never written. You cannot build a “forget-after-inference” health agent with a provider that keeps logs or training data. That is the Venice unlock: perceive, respond, forget.

Architecture (High Level)

Patient → Ingestion (EXIF strip, 60s TTL)
       → Venice STT/Vision (transcribe/analyze → delete raw)
       → AkashML (SOAP, triage, anomaly; text only)
       → Decision (rules ⊕ AI)
       → Delivery (Telegram, TTS) + Persistence (AES-256-GCM SQLite)
       → Audit (append-only, verifiable)

Math-friendly view:

Let x = raw input (image/audio), s = session ID (no patient ID to inference).
Venice: y = f_Venice(x); then x is deleted in T ≤ 60s.
AkashML receives only y (and vitals history as text): d̂ = g_AkashML(y, vitals).
Final decision: d = max(rules(v), d̂), where rules take precedence.

Why Venice + Akash

Concern	Venice AI	Akash
Retention	Zero by design	Provider sees only encrypted data
PHI in inference	Audio/images forgotten after use	AkashML gets text only
Cost	Pay-per-use, no BAA	Decentralized compute
Censorship	Permissionless, medical-safe	Open stack

Security in One Equation

Storage is encrypted; keys are derived, never persisted in plaintext:

key = PBKDF2(passphrase, salt, N=10⁵)
cipher = AES-256-GCM

Audit log is append-only and verifiable → every action has a receipt.

Demo Credentials (Login as Patient)

#	Name	Access Key
1	Maria Santos	9AWCWB
2	James Wilson	CV4IJY
3	Aisha Patel	YZWAUM
4	Robert Chen	QEVY64
5	Elena Rodriguez	3ZLWBZ
6	David Kim	VC6P0J
7	Sarah Johnson	0AJWHD
8	Michael Brown	B7O5F3