Sentinal(Medication Discrepency Agent)
Auth0 Login
Pre-Visit Briefing
Update for Family
Medical Discrepency Email
Vultr

CareSync — The Care Coordination OS

Inspiration

There are 800,000 Personal Support Workers (PSWs) in Canada who care for elderly, disabled, and post-surgical patients at home. Every one of them carries a cognitive load that most people never think about.

When a PSW calls in sick and sends a replacement, that replacement walks in completely blind. No medication history. No behavioral patterns. No record of the fall that almost happened Tuesday, or the wound that has been getting worse since Friday, or the fact that this patient's daughter wants clinical detail but her son panics at medical language. Just a phone number and an address.

We kept coming back to one question: what if the care never forgot, even when the caregiver changed? CareSync is our answer.

What It Does

CareSync is a persistent multi-agent AI operating system for care coordination. It maintains a living memory of every client and puts that memory to work across three agents that run automatically, share context with each other, and get smarter with every visit.

Agent 1 - The Handoff Agent

Fires automatically when a PSW opens a client profile before a visit. It reads the full memory thread and generates a warm, specific, actionable briefing in seconds. Not a database dump. Context that sounds like a colleague who cared for this patient yesterday, because in a way it was: every PSW who logged a visit contributed to what the new caregiver reads.

Agent 2 - The Medication Sentinel

Runs every night at 2 AM on a persistent Vultr server with no user required. It compares what PSWs actually logged giving against what the care plan prescribes, flags any discrepancy back into the client's Backboard memory thread, and sends the coordinator an email digest before the morning shift starts. The coordinator wakes up knowing exactly which patients need attention before anyone walks through a door.

Agent 3 - The Family Communication Agent

Takes one clinical observation and drafts two completely different messages for two different family members, each tailored to that person's stored communication preferences in Backboard memory. One family member gets precise clinical language. The other gets a reassuring plain-English update. Same visit. Same facts. One tap sends both.

How We Built It

Layer	Technology
AI Memory and Agents	Backboard.io
Frontend	React + Vite, deployed on Vercel
Backend API	Node.js + Express on Vultr VPS (Toronto)
Database	Vultr Managed PostgreSQL (Toronto)
Authentication	Auth0 -- three roles: `psw`, `family`, `coordinator`
Document Storage	Vultr Object Storage (S3-compatible)
File Uploads	Multer
Development Environment	Google Antigravity

The Memory Model

Every client has one persistent Backboard thread. Every PSW visit, every agent run, every family interaction updates the same thread, scoped by permissions. If a client has been receiving care for a certain number visits across a certain different PSWs, the context available to any new caregiver is updated accordingly

┌───────────────────────────────────────────────────────────────┐
│                        User Layer                             │
│                                                               │
│   ┌───────────────┐   ┌─────────────────┐   ┌────────────────┐ │
│   │ PSW Mobile    │   │ Family Portal   │   │ Coordinator    │ │
│   │ Web App       │   │ Read-Only View  │   │ Admin Dashboard│ │
│   └───────────────┘   └─────────────────┘   └────────────────┘ │
└───────────────────────────────────────────────────────────────┘
                               │
                               ▼
┌───────────────────────────────────────────────────────────────┐
│                         Auth Layer                            │
│                                                               │
│                     ┌────────────────────┐                    │
│                     │ Auth0              │                    │
│                     │ - JWT Tokens       │                    │
│                     │ - Role Permissions │                    │
│                     │ - Google Login     │                    │
│                     └────────────────────┘                    │
└───────────────────────────────────────────────────────────────┘
                               │
                               ▼
┌───────────────────────────────────────────────────────────────┐
│                      Frontend Layer                           │
│                        (Vercel)                               │
│                                                               │
│                   ┌────────────────────────┐                  │
│                   │ React + Vite           │                  │
│                   │ - Role-Based Views     │                  │
│                   │ - Visit Logging UI     │                  │
│                   │ - Admin Dashboard      │                  │
│                   └────────────────────────┘                  │
└───────────────────────────────────────────────────────────────┘
                               │
                               ▼
┌───────────────────────────────────────────────────────────────┐
│                       Backend Layer                           │
│                   (Vultr VPS - Toronto)                       │
│                                                               │
│        ┌──────────────────────┐   ┌───────────────────────┐   │
│        │ Express API          │   │ node-cron Scheduler   │   │
│        │ - REST Routes        │   │ - 2 AM Sentinel Job   │   │
│        │ - Middleware         │   │ - Risk Monitoring     │   │
│        │ - Auth Validation    │   │                       │   │
│        └──────────────────────┘   └───────────────────────┘   │
└───────────────────────────────────────────────────────────────┘
                               │
                   ┌───────────┴───────────┐
                   ▼                       ▼
┌─────────────────────────────┐   ┌─────────────────────────────┐
│        Data Layer           │   │        AI Layer             │
│     (Vultr Toronto)         │   │        Backboard OS         │
│                             │   │                             │
│ ┌─────────────────────────┐ │   │ ┌─────────────────────────┐ │
│ │ Managed PostgreSQL      │ │   │ │ Persistent Memory       │ │
│ │ - Clients               │ │   │ │ Thread per Client       │ │
│ │ - Visits                │ │   │ │ Shared Across Roles     │ │
│ │ - Users                 │ │   │ └─────────────────────────┘ │
│ │ - Risk Flags            │ │   │                             │
│ └─────────────────────────┘ │   │ ┌─────────────────────────┐ │
│                             │   │ │ Handoff Agent           │ │
│ ┌─────────────────────────┐ │   │ │ Fast Model              │ │
│ │ Object Storage          │ │   │ └─────────────────────────┘ │
│ │ - Discharge PDFs        │ │   │                             │
│ │ - Care Plans            │ │   │ ┌─────────────────────────┐ │
│ └─────────────────────────┘ │   │ │ Sentinel Agent          │ │
│                             │   │ │ Nightly Risk Detection  │ │
│                             │   │ └─────────────────────────┘ │
│                             │   │                             │
│                             │   │ ┌─────────────────────────┐ │
│                             │   │ │ Family Comms Agent      │ │
│                             │   │ │ Status Updates          │ │
│                             │   │ └─────────────────────────┘ │
│                             │   │                             │
│                             │   │ ┌─────────────────────────┐ │
│                             │   │ │ Document RAG            │ │
│                             │   │ │ Care Plan Retrieval     │ │
│                             │   │ └─────────────────────────┘ │
└─────────────────────────────┘   └─────────────────────────────┘

Canadian Data Residency

The Express API, Managed PostgreSQL database, and all patient documents on Object Storage all run on Vultr infrastructure in the Toronto region. No patient data leaves Canada. For a healthcare product, that is not a nice-to-have.

How We Used Google Antigravity

We built the entire project inside Google Antigravity. A few specific places where it made a real difference:

Agent prompt iteration. Getting the Handoff Agent to produce briefings that felt like a colleague rather than a report took a lot of iteration on the Backboard system prompts. Antigravity's inline context-aware suggestions helped us refine the prompt language quickly without losing our place in the codebase.

Auth0 role middleware. The JWT validation and role injection middleware is boilerplate-heavy. Antigravity's tab completion and natural language code commands got the checkJwt and requireRole middleware scaffolded in a fraction of the time it would have taken manually, and correctly the first time.

The cron pipeline. Writing the nightly Sentinel cron loop meant touching node-cron, the Backboard client, the PostgreSQL queries, and the email dispatch all in one flow. Antigravity's configurable agent helped us wire those together without constantly switching context between files.

Vultr Object Storage integration. The S3-compatible client setup and signed URL generation had some non-obvious configuration for the Vultr endpoint. Antigravity surfaced the right patterns without us having to dig through docs.

We would not have shipped all three agents plus role-based auth plus Vultr deployment in 36 hours without it.

Challenges We Ran Into

The cron problem. The Medication Sentinel needs to run at 2 AM regardless of whether any user is logged in. Serverless platforms cannot do this. That pushed us to a Vultr VPS for the backend, which turned out to be the right call for the whole stack: it also gave us a persistent process for the Express API, a place to run the database connection pool, and a server that does not cold-start when a PSW is standing outside a patient's door.

Role-based access on sensitive data. Healthcare data cannot follow a one-size-fits-all permission model. A family member should see care summaries but never raw PSW visit notes. A PSW should see their assigned clients but not every client in the system. We enforced this entirely through Auth0 JWT role claims injected at login via an Auth0 Action, validated on every API route before any Backboard memory is touched. It is not a UI thing. The data simply does not flow if the role does not match.

Making AI output sound human. Early briefing outputs read like structured database reports. We iterated heavily on the Backboard system prompt until the Handoff Agent consistently produced something that sounded like a handoff from a colleague: specific, warm, under 200 words, and ending with one concrete "Watch for today" instruction.

Async document processing without a queue. Uploading a discharge PDF, storing it on Vultr Object Storage, and pushing the extracted text into Backboard's RAG pipeline is too slow to do synchronously in an API response. We built a lightweight async pipeline using native Node.js so uploads return immediately and the RAG ingestion happens in the background without blocking the PSW's workflow.

Accomplishments We're Proud Of

Getting the Sentinel agent to run autonomously at 2 AM, write a flag back into Backboard's persistent memory, and send a coordinator email before anyone wakes up was the moment the product felt real. That is not a chatbot. That is an agent that has a job and does it whether or not any human is involved.

The Family Communication Agent producing two genuinely different messages from one clinical observation is also something we kept showing each other during the build. The contrast between Linda's clinical note and David's reassurance message, both correct, both appropriate, generated from the same event and the same tap, is the clearest demonstration that persistent memory about people is not just useful for patients. It is useful for everyone around them.

What We Learned

Persistent memory across sessions is the feature that makes AI agents genuinely useful in healthcare. Stateless AI cannot coordinate care. An agent that does not remember what happened last Tuesday is not a care coordination tool, it is an autocomplete.

Auth0's role injection via Login Actions is genuinely clean. Three completely different user experiences from one codebase, enforced at the data layer, took about two hours to set up correctly.

The hardest part of building for PSWs is not the technology. It is keeping the interface simple enough to use while driving to the next client. Every extra tap is a feature that will not get used.

Vivirion Ecosystem Integration

CareSync was designed to live inside the Vivirion ecosystem. Vivirion trains and connects Canadian PSWs through education programs, certification, and community tools. CareSync is the operational layer that those trained PSWs need once they are in the field.

A PSW's Vivirion-verified dementia care certification directly informs which clients they are matched to in CareSync. The coordinator dashboard uses Vivirion certification data to make assignment decisions, and as Vivirion's professional networking platform continues to develop, CareSync provides the shared memory that connects PSWs, families, and coordinators around each client's care.

Vivirion builds the workforce. CareSync gives that workforce the context infrastructure they have never had.

What's Next

Voice briefings for PSWs commuting between visits
Medication photo verification via mobile camera
Direct integration with Vivirion's certification API for automated PSW-to-client matching based on verified skills
Provincial health system export for formal care documentation

Built at HackCanada 2026 -- Backboard · Auth0 · Vultr · Google Antigravity · Vivirion Solutions