CareWalker — Post-Discharge Patient Follow-up Agent

Graph-native AI agents that proactively monitor post-discharge patients via natural language. Powered by Jaclang, CareWalker prevents readmissions by turning passive recovery into active care.

Comment

🩺 Inspiration

"1 in 5 patients in India is readmitted to the hospital within 30 days of discharge."

This statistic haunted us. When we dug deeper, we realized it almost never happens because the surgery failed or the medication was wrong. It happens because of the silence after discharge.

Overworked doctors in Tier-2 and Tier-3 clinics — seeing 100+ OPD patients a day — simply do not have the manpower to call every single discharged patient.

When a 60-year-old diabetic patient experiences mild dizziness four days after discharge, they brush it off. By Day 6, it escalates into a severe cardiac event. A simple 30-second check-in could have prevented it.

We were inspired to bridge this dangerous communication gap using Agentic AI — turning passive recovery into proactive care.

🤖 What It Does

CareWalker is a Graph-Native Healthcare Platform. Instead of offering a static, passive chatbot that waits for the user, CareWalker actively spawns a dedicated digital agent (a "Walker") for every patient upon discharge.

These Walkers proactively check in with patients via natural language. They don't just ask generic questions — they traverse a personalized Care Graph:

Diagnosis → Medications → Symptoms to Watch → Risk Threshold → Doctor

Using native by_llm() evaluation, the Walker analyzes the patient's plain-language replies. If a patient says:

"I feel fine but my chest is a bit tight"

...the LLM understands the context, maps it to a critical risk node, halts the standard monitoring protocol, and immediately triggers a high-priority alert on the doctor's dashboard — with zero human intervention.

🛠️ How We Built It

We built the core logical architecture entirely around Jaclang.

By utilizing Jac's graph-native capabilities, we mapped patient recovery pathways physically as Nodes and Edges. This allowed us to constrain the AI, preventing hallucinations and giving the agent a clinical structure to reason within.

node Patient { has name: str, condition: str, risk_score: float = 0.0; }
node SymptomWatch { has symptoms: list[str]; has red_flags: list[str]; }
node RiskThreshold { has threshold: float = 0.7; }
node Doctor { has alert_log: list[str] = []; }

The by_llm() engine was used to natively parse complex patient inputs and map them to risk thresholds — no prompt engineering required:

"""Analyze the patient reply against known symptoms and red flags.
Return a risk score from 0.0 (fine) to 1.0 (emergency)."""
def interpret_reply(reply: str, symptoms: list, flags: list) -> float by llm();

The CareWalker walker traverses the graph node-by-node, assessing each stage of the care pathway and escalating only when the clinical threshold is genuinely crossed.

For the frontend, we engineered a fully responsive 3D Hologram Glassmorphism UI using Vanilla HTML5, CSS3, and JavaScript — breaking away from boring white corporate medical dashboards. We built a custom physics engine to track mouse movements and dynamically tilt the glass cards in 3D space, creating a premium Sci-Fi HUD aesthetic.

🚧 Challenges We Ran Into

Mapping complex, unpredictable medical dialogue into code is notoriously difficult. Traditional chatbots fail because they rely on brittle keyword matching.

Integrating Jac's by_llm() was a breakthrough — but fine-tuning the agent logic so it could distinguish between:

  • "I am doing fine" → Risk: 0.08 ✅
  • "I am fine but dizzy" → Risk: 0.61 ⚠️
  • "Chest pain since last night" → Risk: 0.93 🚨

...required careful state management within the walker's traversal across graph nodes.

Additionally, designing a 3D holographic UI that remained 100% fluid and responsive on mobile required advanced CSS clamp() typography and complex CSS Grid restructuring.

🏆 Accomplishments That We're Proud Of

1. The Architecture Proving that Graph-Native AI is vastly superior to pure LLM wrappers for healthcare — because the graph provides absolute clinical guardrails. The care pathway is the graph. Walkers don't simulate the logic, they are the logic.

2. The UX/UI Crafting an interactive, zero-backend MVP dashboard that dynamically switches context between patients, wrapped in a stunning holographic aesthetic that looks like a million-dollar health-tech startup — built in a single hackathon sprint.

📚 What We Learned

We learned that Agentic AI is most powerful when it has a structured path to follow.

Pure LLMs hallucinate. Graph-Native LLMs execute with precision — because every decision the Walker makes is grounded in a node, an edge, and a clinical constraint. The graph is not just a data model; it is the agent's conscience.

We also learned the massive impact that accessible UI design can have on presenting complex AI logic to non-technical stakeholders — doctors, hospital administrators, and patients alike.

🚀 What's Next for CareWalker

This is just the beginning.

  • Twilio / WhatsApp Integration — Walkers will text patients directly on their phones, requiring zero app installations for the patient.
  • Voice-to-Text for Regional Languages — Elderly patients in rural areas will simply speak their symptoms to their CareWalker in Hindi, Bhojpuri, or Tamil.
  • EHR Integration — Pulling real discharge data from hospital systems to auto-populate each patient's care graph on spawn.
  • Predictive Risk Modeling — Training on anonymized readmission data to sharpen the Walker's risk thresholds over time.

CareWalker is not a chatbot. It is a persistent, graph-native, agentic health companion — one for every patient, running silently until the moment it matters most.

Built With

Share this project:

Updates