Sanjeevani (संजीवनी)

An AI that not only deals , but dials as well

Comment

Sanjeevani — An Autonomous Care Loop That Reaches Patients Where They Are

Tagline: Sanjeevani doesn't just recommend care — it reasons, acts, and learns from what happens next.

Inspiration

Most AI healthcare tools stop at insight. They summarize a symptom, flag a risk score, or generate a recommendation — and then hand the hardest part back to an already-overloaded human.

In rural and underserved communities, that handoff is where care quietly falls through the cracks. A patient's condition can change between visits. Medication adherence can slip. A follow-up that looked unnecessary a few days ago can suddenly become urgent. For ASHA workers and community health workers managing dozens of patients at once, continuously monitoring every one of these changes and manually following up is simply not possible at scale.

We built Sanjeevani around one question: what if an AI system didn't just notice a problem — what if it could reason about it, decide what to do, act on that decision, and learn from the outcome, all while keeping a human in control?

What it does

Sanjeevani is an autonomous, longitudinal care-coordination agent. Instead of treating each patient interaction as an isolated event, it maintains a continuous understanding of a patient's health trajectory and closes the loop between reasoning and real-world action.

The system:

  • Understands patient conversations in their own language through Vaidya, our multilingual health-assistant layer
  • Converts what it learns into structured, longitudinal patient events
  • Analyzes how a patient's condition is trending over time, not just in the latest message
  • Generates a structured Care Decision — risk level, priority, recommended action, reasoning
  • Applies deterministic safety rules to decide whether autonomous follow-up is appropriate
  • Schedules and executes that follow-up — including autonomous phone outreach — without waiting on a human to notice
  • Converts the outcome back into a new patient event and reassesses, so the loop continues as the patient's condition evolves

The result isn't a dashboard that tells a health worker what might need to happen. It's a system that helps the next appropriate action actually happen — safely, and with a human always able to see and override it.

How we built it

Longitudinal reasoning, not single-turn responses. Sanjeevani doesn't just look at the newest patient message — it considers prior events, trajectory, symptom history, and past care decisions before generating a new one. That's what lets it distinguish "a patient mentioned a symptom" from "this patient is measurably declining."

Deterministic gating between reasoning and action. We deliberately did not let the model decide unilaterally to take real-world action. An autonomous follow-up is only triggered when a decision meets explicit, auditable thresholds — decision type, risk level, priority, and a valid contact channel all have to align. Every other case routes to human review instead. This makes the system's behavior predictable and inspectable rather than a black box.

Action, not just alerting. When autonomous follow-up is warranted, Sanjeevani schedules and executes real outreach — including autonomous phone conversations that collect structured information (symptom status, medication adherence, urgency) and feed it straight back into the patient's record.

A genuine feedback loop. The outcome of an action becomes a new patient event, which re-triggers reassessment, which can produce a new Care Decision. The system is not reason → act → done; it's reason → act → learn → reason again.

Human oversight by design. The ASHA-facing dashboard surfaces every layer of this: patients needing attention, current risk and trajectory, care decisions, scheduled and completed follow-ups, and structured outcomes — so a human is never out of the loop, just no longer required to be the bottleneck.

Architecture

Patient conversation (Vaidya, multilingual)
        ↓
   Patient Event
        ↓
Sanjeevani longitudinal reasoning
        ↓
   Care Decision
        ↓
Deterministic eligibility check
        ↓
  Autonomous action (e.g. scheduled follow-up call)
        ↓
  Structured outcome
        ↓
  New Patient Event
        ↓
   Reassessment → New Care Decision

Agent lifecycle: OBSERVE → REMEMBER → ANALYZE → ASSESS → REASON → PLAN → EXECUTE → COMMUNICATE → REPLAN

Built with

  • Frontend: React, Vite, JavaScript, Axios, React Router
  • Backend: Node.js, Express, MongoDB, Mongoose
  • Agent platform: Google ADK, Gemini
  • Infrastructure: Google Cloud Run
  • Voice / multilingual layer: Sarvam AI voice pipeline (shared with Vaidya)

Challenges we ran into

The hardest problem wasn't connecting a model to patient data — it was deciding when the system should be allowed to act autonomously in a healthcare context, where a wrong autonomous action carries real weight. We solved this by explicitly separating clinical reasoning from execution: the model proposes, but only a deterministic, auditable rule set can authorize real-world action.

The second challenge was making action outcomes genuinely re-enter the system's reasoning rather than being a dead-end log entry. That required designing the whole pipeline — event → decision → action → outcome → reassessment — as a real loop from the start, not bolting feedback on afterward.

Accomplishments that we're proud of

We're proud that Sanjeevani is a complete, closed loop — not a demo that stops at "here's what the AI thinks." It reasons over longitudinal data, decides, acts, and learns from what happens, while keeping a human able to see and intervene at every stage. We're especially proud of keeping that human oversight intact: the system never attempts to replace clinical judgment, diagnose, or prescribe — it closes the operational gap between insight and follow-through.

What's next

  • Broaden the channels through which Sanjeevani can autonomously reach patients
  • Improve failure handling and retry behavior for autonomous actions
  • Support recurring, longer-horizon follow-up workflows
  • Deepen longitudinal care analytics for ASHA workers
  • Expand multilingual coverage across more of Vaidya's supported languages

The core principle stays the same: AI shouldn't just tell a health worker what might need to happen next. It should help make the next appropriate action happen — safely, transparently, and with humans always in the loop.

Built With

Share this project:

Updates

Submission history