Project Info

Winner

Best Use of The Agentverse by Fetch AI

CareLoop

This project did not submit a demo video on Devpost.

Inspiration

CareLoop was inspired by how stressful healthcare navigation can be. Even when someone knows they need care, they still have to figure out urgency, insurance, cost, providers, and booking, often while anxious or helping a loved one.

What it does

CareLoop lets users describe a health concern by voice or text. It triages urgency, routes emergencies to 911, finds nearby providers, estimates out-of-pocket cost, and helps guide appointment booking in one conversation.

How we built it

We built CareLoop with Fetch.ai uAgents, ASI:One, Deepgram voice, FastAPI, Redis, Stripe, and CMS NPPES provider data. A main orchestrator agent coordinates specialist agents for triage, provider search, cost estimation, scheduling, and payment.

Challenges we ran into

The hardest part was making many moving pieces feel simple: voice input, AI reasoning, agent messaging, provider data, payments, and booking. We also had to build strong safety guardrails so emergency symptoms are handled immediately.

Accomplishments we're proud of

We are proud that CareLoop feels like a real healthcare access workflow, not just a chatbot. It combines voice, agents, real provider data, cost estimates, booking flow, fallback logic, and emergency routing into one usable demo.

What we learned

We learned that healthcare AI needs structure as much as intelligence. Clear agent roles, state management, safety rules, and honest limitations are what make the experience trustworthy.

What's next

Next, we would integrate live insurance eligibility, real appointment availability, provider booking APIs, multilingual caregiver workflows, and stronger clinical review so CareLoop can move from demo to dependable care navigation.

CareLoop — a voice-first, multi-agent healthcare-access concierge

Speak a health problem in plain language and CareLoop's team of AI agents triages urgency → finds real in-network providers → estimates your out-of-pocket cost → books an appointment — then reads the confirmation back to you by voice.

Built for the UC Berkeley AI Hackathon 2026: Fetch.ai (uAgents + ASI:One) multi-agent orchestration, Anthropic Claude clinical triage, a Deepgram voice layer, Redis caching/state, and Stripe payments. Developed with Claude Code.

⚠️ CareLoop is a navigation aid, not a medical provider. It does not diagnose. Red-flag symptoms (chest pain, stroke signs, trouble breathing, etc.) are routed straight to 911 and never to a booking.

Why it matters

The hardest part of healthcare for many people — elderly patients, caregivers, non-native English speakers, anyone in distress — isn't the medicine, it's the navigation: Who do I see? Is it urgent? Who's nearby and takes my insurance? What will it cost? How do I book it? CareLoop collapses that maze into one calm conversation you can have by voice, in your own language.

How it works (architecture)

              ┌──────────────── ASI:One chat ────────────────┐    🎙 Browser voice app + 📊 dashboard
              │   (Agent Chat Protocol — no frontend needed)  │       (Deepgram STT/TTS, interactive cards)
              └───────────────────────┬──────────────────────┘                 │  POST /voice (REST)
                            ChatMessage │                                       │
                                        ▼                                       ▼
   ┌─────────────────────────────  Orchestrator Agent  ──────────────────────────────┐
   │  ASI:One LLM: parse intent, manage the conversation, compose replies + cards      │
   └──┬──────────┬──────────┬──────────┬───────────┬──────────┬───────────────────────┘
      │ send_and_receive (agent-to-agent messaging via Agentverse)
      ▼          ▼          ▼          ▼           ▼          ▼
  ┌────────┐┌──────────┐┌────────┐┌──────────┐┌────────┐┌────────────┐
  │ Triage ││ Provider ││  Cost  ││ Scheduler││Payment ││  Evidence  │
  │  911   ││CMS NPPES ││  est.  ││  .ics +  ││ Stripe ││  trials +  │
  │ rules  ││          ││        ││ confirm  ││ deposit││ drug safety│
  └────────┘└──────────┘└────────┘└──────────┘└────────┘└────────────┘

7 agents, each registered on Agentverse with its own mailbox + profile.
The Orchestrator speaks the Agent Chat Protocol, so the entire workflow runs from ASI:One with no custom frontend — then the Deepgram web app layers a natural voice experience (and interactive cards) on top of the same agent.
Real data: providers from CMS NPPES, recruiting trials from ClinicalTrials.gov, drug-safety from openFDA.
Takes action: for serious/chronic conditions it surfaces relevant clinical trials + drug-safety notes, and it completes a real (test-mode) Stripe deposit before booking.
Resilient: every agent-to-agent call falls back to in-process logic, so a single agent hiccup never breaks the demo.
Redis is shared infrastructure across all agent processes: a provider/triage/ trials cache (huge repeat-latency savings), a session store, a Streams audit trail, and live stat counters — all degrading gracefully if Redis is offline.

The agents

Agent	Address (derived from seed)	Role
Orchestrator	`agent1qfxka5afzlk2wsp3agw77l7gz426d9vymwr9l4cfhy2gdvvhq2h8kn798uc`	ASI:One-facing brain; chat protocol + voice REST
Triage	`agent1q29ewatrgfnskvkk020y3p2n7qkl36xw293v4x74kpy49czdjqxrqxl9xpe`	Claude-powered urgency + specialty reasoning; hard 911 red-flag rules
Provider-Finder	`agent1qdjaj2ctxsjs3vpt5j7uxk46vq9znrquhn9q8fkljqhjueqrr93nzwj3whq`	Real providers from CMS NPPES (filtered to the requested city/state)
Cost-Estimator	`agent1qtrge69qnynvpfwd7duw9pgjeffsmmlemflyz06v6v4r2yndtvcwq5k4sd6`	Plan-, provider- & region-aware out-of-pocket estimate
Scheduler	`agent1q0d726utvqsgjmctt4etsclcapk9tvx75t7tlrcp0luyvsecyr7yz9ujgyf`	Confirmation + iCalendar invite
Payment	`agent1qdr7s04hzndeefr2tt085nt29q8jxklf8hne9yhchn63huey9eurczs5ux5`	Stripe Checkout deposit + server-side verify
Evidence	`agent1qt2nusghdan489nh92w37ax33gz8yxfuklezkph029eyju5dyt7vv7m2eag`	Recruiting clinical trials (ClinicalTrials.gov) + drug safety (openFDA)

Profile URL pattern: https://agentverse.ai/agents/details/<address>/profile (run ./venv/bin/python -m scripts.print_addresses to reprint).

Quick start

# 1. Install
python3 -m venv venv && ./venv/bin/pip install -r requirements.txt

# 2. Configure keys
cp .env.example .env   # fill in ASI1_API_KEY, AGENTVERSE_API_KEY, DEEPGRAM_API_KEY
                       # optional: STRIPE_SECRET_KEY (deposit), REDIS_URL

# 3. One command: starts Redis + all 7 agents + voice app, registers, runs a full demo
./scripts/demo.sh
#    -> then open the voice app at http://127.0.0.1:8080
#       and the live dashboard at http://127.0.0.1:8080/dashboard

./venv/bin/python -m scripts.selftest          # sanity-check the pipeline (no keys/network needed)
redis-server --daemonize yes                   # or: docker run -d --name careloop-redis -p 6379:6379 redis:7-alpine
./scripts/run_all.sh                           # start all 7 agents (each in its own process + mailbox)
./venv/bin/python -m scripts.register_agents   # auto-register every mailbox on Agentverse (no browser clicks)
./venv/bin/uvicorn voice.backend:app --port 8080

ASI:One promo code: BERKELEYAI · Agentverse promo code: BERKELEYAIAV

Try it

Golden path (books a real provider):

my dad has had a bad cough and a low fever for five days,
he's on Medicare and we're in Berkeley

→ "…I'd start with Primary Care … the best match near Berkeley is Allison Aiken, M.D. at 2222 Bancroft Way with an opening in 2 days … with a provider- and plan-specific out-of-pocket estimate … want me to book it?" → "yes" → pay a refundable $25 deposit via a real Stripe Checkout link (test card 4242 4242 4242 4242) → "done" → agent verifies payment → ✅ booked + calendar invite.

If STRIPE_SECRET_KEY is not set, CareLoop skips the deposit and books directly.

Clinical-evidence path (serious/chronic condition → real recruiting trials + drug safety):

my mom was diagnosed with early-stage breast cancer,
she's in San Francisco on Medicare and takes tamoxifen

→ routes to Oncology, names a real SF oncologist, and surfaces recruiting clinical trials near her (ClinicalTrials.gov) plus a tamoxifen drug-interaction note (openFDA) — options to discuss with her doctor.

Emergency path (routes to 911, no booking):

I'm having crushing chest pain and I can't breathe

Tech

Fetch.ai uAgents — multi-agent framework, Agentverse mailboxes, Almanac discovery
Agent Chat Protocol — ASI:One discoverability & chat
ASI:One (asi1-mini) — orchestrator intent parsing + reply composition
Anthropic Claude (claude-sonnet-4-6) — triage clinical reasoning (falls back to ASI:One)
Deepgram — Nova-3 STT (multilingual) + Aura-2 TTS
Stripe — real (test-mode) Checkout for a refundable booking deposit, verified server-side
Redis (beyond caching) — shared provider/triage/trials cache (91×–853× faster on repeats), session store, Streams audit trail of every clinical/payment/booking decision, live stat counters
CMS NPPES — real provider data · ClinicalTrials.gov — recruiting trials · openFDA — drug safety
FastAPI — voice web app + interactive cards + live /dashboard

Deliverables

🔗 ASI:One shared chat: add link here
🤖 Agentverse profiles: see the table above
🎬 Demo video: add link here
📦 This repo

Repository layout

agents/           orchestrator + 6 specialists (triage, provider, cost, scheduler,
                  payment, evidence); shared logic/models/prompts/clients; profile READMEs
voice/            FastAPI Deepgram bridge + click-to-talk web UI + /dashboard
data/             taxonomy map + illustrative cost model
scripts/          demo.sh, showcase.py, selftest, run_all.sh, register_agents, print_addresses
docs/             UI/UX plan + interactive-card API contract

Safety & honesty

Triage is navigation, not diagnosis; disclaimers shown throughout.
Hard-coded red-flag rules force 911 escalation before any LLM call.
Provider names/addresses are real (NPPES); appointment slots and insurance acceptance are synthesized and labeled as estimates — NPPES has no such data.

Developed with Claude Code for the UC Berkeley AI Hackathon 2026.

Analysis

Compare with all teams

View

Metric

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

AnthropicIn code
CSSIn code
FastAPIIn code
HTMLIn code
JavaScriptIn code
OpenAIIn code
PythonIn code
RedisIn code

8 of 8 appear in the indexed code.

AI coding agents

Claude CodeConfig · Commits

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

225 KB

Source files

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.

Feature verification

13 Verified3 Code-supported2 Claimed only

Agent Chat Protocol for ASI:One (no custom frontend needed)Verified
The Orchestrator speaks the Agent Chat Protocol so the entire workflow runs from ASI:One with no custom frontend
Claimed on readmehigh confidence
- agents/orchestrator.py:15 — Imports ChatMessage, chat_protocol_spec from uagents_core.contrib.protocols.chat
- agents/orchestrator.py:123 — Protocol(spec=chat_protocol_spec) with on_chat handler and agent.include(chat_proto, publish_manifest=True)
Claude-powered clinical triage with ASI:One fallbackVerified
Anthropic Claude performs clinical triage reasoning, falling back to ASI:One
Claimed on readmehigh confidence
- agents/common/claude_llm.py:21 — Anthropic client configured with claude-sonnet-4-6 model
- agents/common/logic.py:108 — Uses claude_llm.chat_json if available, else falls back to asi.chat_json, else keyword heuristic
Clinical trials + drug safety evidence lookupVerified
Surfaces recruiting clinical trials (ClinicalTrials.gov) and drug-safety notes (openFDA) for serious/chronic conditions
Claimed on readmehigh confidence
- agents/common/clinical.py:44 — Calls clinicaltrials.gov/api/v2/studies filtering RECRUITING status
- agents/common/clinical.py:76 — Calls api.fda.gov/drug/label.json for interaction/warning notes
- agents/evidence.py:23 — Evidence agent triggers clinical trial/drug lookup when condition present
Emergency 911 routing with hard-coded red-flag rulesVerified
Routes emergencies to 911 via hard-coded red-flag rules that run before any LLM call
Claimed on readmehigh confidence
- agents/common/logic.py:33 — RED_FLAG_PATTERNS regex list for chest pain, stroke signs, etc.
- agents/common/logic.py:81 — triage() checks red flags first and returns emergency=True before reaching the LLM call
Fetch.ai uAgents multi-agent orchestration with Agentverse mailboxesVerified
7 agents, each registered on Agentverse with its own mailbox, orchestrator coordinates specialist agents via agent-to-agent messaging
Claimed on readmehigh confidence
- agents/orchestrator.py:40 — Agent(..., mailbox=True) construction
- agents/orchestrator.py:65 — AgentSpecialists._call uses ctx.send_and_receive for agent-to-agent messaging with local fallback
- agents/common/config.py:26 — Seeds/ports/addresses defined for a 7-agent mesh
- requirements.txt:4 — uagents and uagents-core dependencies present
Live dashboard UIVerified
A live dashboard at /dashboard shows stats/audit trail
Claimed on readmehigh confidence
- voice/backend.py:256 — /dashboard route serves dashboard.html and /api/dashboard returns live stat/audit data
- voice/static/dashboard.html — Dashboard frontend file present
Nearby provider search using real CMS NPPES dataVerified
Finds nearby providers using real CMS NPPES provider data, filtered to requested city/state
Claimed on readmehigh confidence
- agents/common/nppes.py:21 — Real HTTP calls to npiregistry.cms.hhs.gov/api
- agents/common/nppes.py:59 — _matches_requested_location filters results to requested city/state
- agents/provider_finder.py:26 — Wires NPPES lookup into the provider_finder agent with fallback data
Out-of-pocket cost estimation (plan/provider/region-aware)Verified
Estimates out-of-pocket cost based on plan, provider, and region
Claimed on Devposthigh confidence
- agents/common/logic.py:169 — estimate_cost() uses cost_table.json plus region multiplier and per-provider multiplier
- data/cost_table.json — Illustrative cost table backing the estimate; self-labeled as illustrative, not real plan data
- agents/cost.py:24 — Wires estimate_cost into the cost agent
Redis shared infrastructure (cache, session, streams audit trail, stat counters)Verified
Redis provides provider/triage/trials caching, session store, Streams audit trail, and live stat counters, degrading gracefully if offline
Claimed on readmehigh confidence
- agents/common/store.py:66 — Implements cache_get_json/cache_set_json with TTL
- agents/common/store.py:98 — xadd/xrevrange implement a Streams audit trail
- agents/common/store.py:117 — hincrby/hgetall implement live stat counters
- agents/common/store.py:51 — _safe wrapper makes all Redis operations fail gracefully if Redis is offline
Resilient fallback: agent-to-agent calls fall back to in-process logicVerified
Every agent-to-agent call falls back to in-process logic so a single agent hiccup never breaks the demo
Claimed on readmehigh confidence
- agents/orchestrator.py:65 — AgentSpecialists._call attempts send_and_receive and falls back to local logic on failure/timeout
Stripe test-mode deposit payment with server-side verificationVerified
Completes a real (test-mode) Stripe deposit before booking, verified server-side
Claimed on readmehigh confidence
- agents/common/stripe_pay.py:41 — Creates a real stripe.checkout.Session using test-mode secret key from env
- agents/common/stripe_pay.py:71 — verify() retrieves the session server-side and checks payment_status == paid
- agents/payment.py:28 — Wires create/verify into payment agent message handlers
Text input alternativeVerified
Users can also describe a health concern by text
Claimed on Devposthigh confidence
- voice/backend.py:321 — /api/converse and related text chat routes accept plain text input to the orchestrator
Voice input/output via DeepgramVerified
Users describe a health concern by voice; Deepgram STT/TTS reads confirmations back
Claimed on readmehigh confidence
- voice/backend.py:63 — deepgram_stt() calls Deepgram REST API
- voice/backend.py:83 — deepgram_tts() calls Deepgram REST API
- voice/static/app.js:509 — Browser MediaRecorder captures mic audio and posts to /api/converse
Appointment booking with iCalendar confirmationCode-supported
Helps guide appointment booking, generating a scheduler confirmation + iCalendar invite
Claimed on readmemedium confidence
- agents/common/logic.py:251 — _make_ics builds a real RFC5545 VCALENDAR/VEVENT block
- agents/scheduler.py:22 — Wires booking/.ics generation into the scheduler agent, but booking itself is against synthesized (not real) appointment availability, per module docstring
Auto-register agents on Agentverse via scriptCode-supported
run scripts/register_agents.py to auto-register every mailbox on Agentverse without browser clicks
Claimed on readmemedium confidence
- scripts/register_agents.py:61 — Script posts Agentverse API token to register mailbox/profile/README, but actual successful registration requires live network/API keys and cannot be confirmed from static code alone
Multilingual voice via Deepgram Nova-3 STTCode-supported
Deepgram Nova-3 STT (multilingual) supports non-native English speakers
Claimed on readmelow confidence
- voice/backend.py:63 — deepgram_stt() calls Deepgram STT API but multilingual model selection/language handling was not confirmed beyond the base STT call
ASI:One shared chat link and demo video deliverablesClaimed only
Deliverables include an ASI:One shared chat link and a demo video
Claimed on readmehigh confidence
Future roadmap items (live insurance eligibility, real booking APIs, multilingual caregiver workflows, clinical review)Claimed only
Next steps: integrate live insurance eligibility, real appointment availability, provider booking APIs, multilingual caregiver workflows, stronger clinical review
Claimed on Devposthigh confidence

An AI agent derived these features from the project’s Devpost page and readme, then searched the code for each one. Verified features are backed by cited code; claimed-only features had no supporting code, which is not by itself proof a feature is missing.