Sanjeevani (संजीवनी)

Life-giving care, revived by attention.

Comment

Sanjeevani

Life-giving care, revived by attention.

In the old stories, Sanjeevani was the herb that revived the dying. This is an agent built on the same idea: notice the decline before it becomes the crisis.

Track: The Taskmaster

Requirements

Sanjeevani satisfies all three mandatory technical requirements for this hackathon:

  1. Gemini 3.5 — accessed through the Gemini API, used as the sole reasoning engine: interpreting patient trajectories, choosing which tools to call and in what order, making the four-level decision (MAINTAIN / INCREASE / URGENT / ESCALATE), and generating the plain-language explanation behind every decision.
  2. Google Agent Framework — built on the Google Agent Development Kit (ADK), using an LlmAgent that dynamically selects its own tools rather than following a fixed, scripted pipeline.
  3. Google Cloud infrastructure — the backend is deployed on Cloud Run, which is what makes "continuously monitoring a population" a real, live system rather than a local simulation running only during the demo.

Inspiration

The Taskmaster track asks for a real workflow, not a chatbot — an agent that takes action and proves it can carry real load. We found that friction in something we'd both seen up close: an ASHA worker in rural India isn't managing one conversation at a time, she's managing dozens of ongoing patient stories at once — symptoms shifting, medicines not taken, follow-ups missed — with no realistic way to hold all of it in her head every single day.

We named the project Sanjeevani after the life-reviving herb from the old stories, because the idea underneath it is the same: notice the decline early enough that the crisis never has to happen. Most digital health tools only solve half of that problem — they record what happened and show it to her, but they don't decide what needs her attention next, and they don't do it continuously.

What it does

Sanjeevani is an autonomous care-coordination agent. It doesn't wait for an ASHA worker to manually review every patient — it continuously reasons over each patient's trajectory through a defined loop: Observe, Remember, Analyze, Assess, Decide, Replan, Act, Remember.

When a new health event arrives, the agent doesn't react in isolation. It retrieves the patient's relevant history, analyzes the current event against that history, and assesses risk and trajectory together before deciding. The decision itself has real texture — one of four levels, MAINTAIN, INCREASE, URGENT, or ESCALATE — not a binary flag.

The most important part of the loop is the boundary the agent respects: when a case crosses into genuine human judgment, it pauses and hands the case to an ASHA worker rather than resolving it alone. It replans and acts only after that review. The system is deliberately not a diagnostic tool — it operates within configured care-protocol bands and never produces a diagnosis. High-stakes clinical judgment stays with a human, by design.

We verified the reasoning loop end to end in both directions, because a trustworthy agent has to know when not to act, too:

  • Worsening case: rising fatigue, new dizziness, dropping medication adherence — the agent independently reasoned through the evidence and moved the decision to ESCALATE.
  • Stable case: steady symptoms, no deterioration — the same agent, same tools, correctly landed on MAINTAIN, leaving the plan unchanged.

On the patient side, Vaidya is where the whole loop actually starts. A patient speaks or types in their own language — no medical terminology, no second language required — and that becomes the structured health event the agent reasons over.

How we built it

The agent runs on the Google Agent Development Kit, as a single LlmAgent with a defined tool set: retrieving patient context, timeline, and memory, analyzing trajectory, checking the active care plan and prior decisions, and creating or updating decisions and care plans. Gemini chooses which tools to call, and in what order — this isn't a fixed, scripted sequence. In our verified runs, Gemini independently called multiple retrieval tools in parallel before synthesizing them into a decision.

Every agent execution produces a full, persisted execution record — every tool call, every reasoning step — and is fully replayable, which matters for a hackathon specifically because the judging criteria ask for proof of execution, not just a claim.

The system is deployed on Cloud Run, and persistent state is maintained in MongoDB, so the agent's judgment about a patient today is genuinely informed by what it observed weeks earlier.

On the patient-facing side, Vaidya uses Sarvam AI for speech-to-text, translation, and text-to-speech, so a patient can speak naturally in their own language and have it become structured signal — the accessibility layer that makes the agent usable by the people it's actually built for, not the core innovation itself.

Challenges we ran into

The hardest problem wasn't getting Gemini to sound confident about a decision — it was getting the agent to correctly recognize when it didn't have enough evidence to act, and building the Human Boundary correctly: recognizing which decisions the agent should make on its own and which genuinely require a person, without either over-escalating everything or quietly overriding a boundary it shouldn't cross.

We also had to resist adding more agents and more Google Cloud services than the problem needed. It would have been easy to name every available service in the writeup. We chose to build and verify a smaller set — Gemini, ADK, and Cloud Run — completely, rather than claim a longer list only partially working.

Accomplishments that we're proud of

We're proud that Sanjeevani doesn't just claim to be agentic — we can replay the actual execution trace of a real decision, tool call by tool call, and show exactly what happened, live and unedited. We're equally proud of verifying the restraint case: an agent that knows when to do nothing, and when to defer to a human, is a harder thing to build convincingly than one that always intervenes.

What we learned

We learned that the hardest part of an autonomous agent isn't giving it more capability — it's giving it the judgment to recognize insufficient evidence and the discipline to stay within a defined protocol, including knowing when the right action is to stop and wait for a human.

We also learned that restraint in scope is itself an engineering decision. Keeping the tech stack to what we could fully build and verify — rather than everything available — forced us to make the core loop genuinely solid instead of spreading effort across claims we couldn't back up on camera.

What's next for Sanjeevani

We want to complete full production deployment, extend the Human Boundary logic with richer escalation protocols, and validate the reprioritization logic against real, anonymized ASHA worker workflows rather than our current simulated patient population.

Built With

Share this project:

Updates

Submission history