4 ready-to-build workflows

AI agent workflows for Personal health & medical records

Prescriptions in a plastic folder, lab reports lost in the photo gallery, a parent phoning to ask which tablet is the white one — organised, reminded and translated, with an absolute rule: it never diagnoses, never touches a dose, and always sends you to the doctor.

Each recipe below is expressed only in VegaDūta's real workflow building blocks — Trigger, Agent, Knowledge, Condition, Approval, Output, Tool (MCP), Voice, Device, Loop, Code and Parallel — so it maps 1:1 to something you can assemble in the Workflow designer. Consequential actions always pass a human Approval step.

1. Every report and prescription in one timeline, ready for the next visit

The prescriptions are in a plastic folder in date-ish order. The lab reports are photographs somewhere between a birthday and a holiday. At the next appointment the doctor asks 'what was your HbA1c in March?' and you scroll through eight months of gallery while everyone waits, or you say 'I'll bring it next time' and the visit achieves less than it should have.

Trigger: WhatsApp (photograph a report or prescription) / Email (lab sends a PDF)

How the workflow runs

  1. Trigger

    Send it the moment you get it. A WhatsApp trigger for photographs and an Email trigger for the PDFs labs mail out. Filing happens at the counter, not later — which is the only time it ever actually happens.

  2. Agent

    Transcribe, don't interpret. An Agent node extracts what is printed: test name, value, unit, the lab's own reference range, date, doctor, and for a prescription the drug names and the schedule AS WRITTEN. It transcribes; it does not say whether a number is good or bad.

  3. Knowledge

    Your own health file. A Knowledge node keeps it in your tenant, per family member — this is your records, not a shared health database.

  4. Tool (MCP)

    How old is this reading?. A user-defined SpEL tool labels each entry by age so 'the most recent one' is a fact rather than a memory. It computes a bucket from the input JSON — a formula, nothing else.

  5. Loop

    Build the timeline. A Loop node walks the filed entries for a chosen test and lays out the values in date order — the same numbers the reports carry, side by side, so a doctor can see the sequence at a glance.

  6. Agent

    Prepare, never conclude. A second Agent node writes a one-page visit sheet: current medicines as prescribed, the timeline of the values, and questions worth asking. It never adds an assessment, a trend judgement, or a suggestion.

  7. Approval

    Sharing is your decision. An Approval node gates sending anything to a doctor, a relative, or an insurer — health records don't leave your tenant on the agent's initiative.

  8. Output

    One page you can hand over. An Output node produces the sheet on WhatsApp or Email, in the language you want, ready to hand to the doctor or read on the way in.

Channels & connectors

  • WhatsApp
  • Email
  • Knowledge base
  • Approval / HITL
  • Sarvam (Indian languages)
  • Tool (MCP → a lab or hospital portal, if yours has one)

Outcome

One dated, per-person health timeline built from the reports you already receive, and a one-page visit sheet that turns a scattered folder into a doctor's ten useful minutes.

Why it helps

The mechanism is transcription plus ordering — nothing more, deliberately. The reason a visit underdelivers is that the doctor's questions are about sequence ('has it moved since March?') and your evidence is unordered. Putting the same printed numbers in date order answers that without anyone, human or model, interpreting them.

Build spec

2 agents1 transcription agent per report + 1 visit-sheet composer per appointment. No agent ever evaluates a value; the timeline is assembled by a Loop node over filed records. · Pattern: Transcribe-on-arrival → assemble-on-demand, with interpretation excluded by design

System prompt (paste-ready)

(Transcription) You transcribe medical documents for a patient's personal records. Return strict JSON {doc_type (LAB_REPORT|PRESCRIPTION|DISCHARGE|SCAN_REPORT), patient, date, doctor, facility, tests[{name, value, unit, reference_range_as_printed}], medicines[{name_as_written, strength, schedule_as_written, duration}], notes_as_written}. Transcribe EXACTLY what is printed, including the lab's own reference range verbatim. You must NOT say whether a value is normal, high, low, safe, concerning or improved. You must NOT name a condition, suggest a diagnosis, or comment on any medicine or dose. If a field is unreadable, return null and set needs_check=true naming the field — never guess a value, a strength or a schedule. If the document seems to describe an emergency, do not assess it: flag escalate=true so the workflow tells the person to contact their doctor or emergency services.

Agent roles & model tiers

  • Transcriber (per document) Economy tier — pure structured extraction, and it runs on every report and prescription the family receives

    Transcribe exactly what is printed into strict JSON, reference ranges verbatim. No interpretation of any kind. Unreadable fields are null + needs_check, never guessed.
  • Visit-sheet composer (per appointment) Standard tier — runs once before a visit; this is where care with wording matters most

    Assemble a one-page visit sheet: current medicines exactly as prescribed, the requested test values in date order with the printed reference ranges, and questions the patient may want to ask the doctor. Add NO assessment, NO trend judgement, NO suggestion. Questions must be neutral and open ('what does this trend mean for me?'), never leading ('should my dose be increased?'). End with a line stating that this sheet is a record for the doctor and is not medical advice.

MCP connectors

  • Your lab's or hospital's portal, if it has one — via a Tool (MCP) node (no first-party connector); read-only and initiated by you
  • WhatsApp / Email — how reports arrive and how the sheet comes back

Built-in tools

  • user-defined tool `report_recency` (SpEL): input.daysSinceTest <= 30 ? 'RECENT' : (input.daysSinceTest <= 180 ? 'THIS_HALF' : 'OLDER') — your own definition of what counts as a current reading, so the visit sheet leads with the right one; it is a formula over the input JSON with no method calls and no loops
  • knowledge_search (your own filed reports and prescriptions, per family member)
  • send_email (the visit sheet to yourself, so it exists outside chat when the phone dies in the waiting room)

Guardrails

  • MEDICAL SAFETY, absolute: the agent NEVER diagnoses, NEVER names a condition, NEVER calls a value normal/abnormal/safe/concerning, and NEVER advises on, changes or comments on any medicine or dose. It transcribes, orders, translates and prepares questions — nothing else
  • Reference ranges are reproduced verbatim from the lab's own report and are never compared against by the agent — the comparison is the doctor's, not the model's
  • Anything suggesting an emergency sets escalate=true and the workflow responds with 'contact your doctor or emergency services now', with no assessment of severity attached
  • Unreadable values, strengths and schedules are returned null with needs_check — a guessed dose is the single most dangerous output this workflow could produce, so it is structurally excluded
  • PRIVACY: health records stay in your own tenant, filed per family member. Nothing goes to a doctor, relative, employer or insurer without passing the Approval node
  • The visit sheet carries an explicit line stating it is a personal record for the doctor, not medical advice

Cost strategy

The transcriber runs on every incoming report, so it belongs on the economy tier with a hard token cap — it is doing structured extraction, not reasoning, and a cheaper model is genuinely the right tool. The composer runs once before an appointment: standard tier, and worth it, because careful non-interpretive wording is exactly what smaller models drift away from. Configure a fallback model on the transcriber so filing never silently stops; the timeline itself is assembled by a Loop node over stored records, which costs nothing per read.

Output & delivery

Each report or prescription is transcribed verbatim into your per-person Knowledge base; the `report_recency` SpEL tool marks how current each reading is; a Loop node lays the requested values out in date order with their printed reference ranges; the composer produces a one-page visit sheet — medicines as prescribed, the timeline, and neutral questions for the doctor — delivered on WhatsApp or Email in your language, with any sharing beyond you gated by the Approval node.

2. A voice reminder for an elderly parent, in their own language

Your mother is on six tablets. Two in the morning, one after lunch, three at night, one of them only on alternate days. She phones you at work to ask whether the white one is the morning one, and you're in a meeting trying to picture a strip of tablets from four hundred kilometres away. Some days nobody calls and nobody knows whether the evening dose happened.

Trigger: Webhook (scheduled dose times) / Voice (she calls and asks)

How the workflow runs

  1. Trigger

    The schedule the doctor wrote. A scheduled Webhook fires at each dose time from the schedule transcribed off the actual prescription — not a schedule anyone typed from memory.

  2. Knowledge

    The prescription itself. A Knowledge node holds the transcribed prescription: medicine names, strengths and timings exactly as written by the doctor, plus the description you added ('the small white one, in the blue strip').

  3. Voice

    A call in her language. A Voice node calls and speaks in her language — Sarvam for Indian languages, ElevenLabs for a natural voice. It reads out what the doctor prescribed for this time slot, slowly, and repeats it if she asks.

  4. Agent

    Read back, never advise. An Agent node handles her questions by reading back the prescription verbatim. 'Which is the morning tablet?' gets the doctor's own words plus your description. 'Should I take an extra one?' gets a kind refusal and an offer to reach you or the doctor — always, without exception.

  5. Condition

    Was it taken?. A Condition node handles the answer: confirmed goes to the log; no answer or an unclear one, after a retry, goes to the family.

  6. Tool (MCP)

    How many days of stock left?. A user-defined SpEL tool divides tablets remaining by tablets per day so the refill reminder arrives before the strip runs out. Arithmetic over the input JSON — that is the whole tool, and by construction it can be nothing more.

  7. Output

    Family gets told. An Output node sends the family WhatsApp group a quiet daily line — doses confirmed, doses missed — so nobody has to ring to find out, and a missed one is visible the same day.

  8. Approval

    Any change to the schedule is human. An Approval node means the reminder schedule can only be changed by a family member entering what the doctor said — never by the agent, and never by the patient asking it to.

Channels & connectors

  • Voice/Call
  • ElevenLabs (voice)
  • Sarvam (Indian languages)
  • WhatsApp
  • SMS/Twilio
  • Webhook (scheduled)
  • Knowledge base
  • Approval / HITL

Outcome

A gentle call at each dose time in her own language that reads back exactly what the doctor prescribed, a daily line to the family about what was taken, and a refill reminder before the strip empties.

Why it helps

The mechanism is read-back, not judgement. The daily confusion isn't a medical question at all — it's that the schedule lives on a piece of paper she can't easily read and in her children's memory four hundred kilometres away. A voice that speaks her language and reads the doctor's own words removes the confusion without anyone giving advice, and the family log turns 'I think she took it' into a fact someone can see.

Build spec

1 agent1 read-back agent on the call. The schedule, the retry, the family notification and the refill maths are workflow nodes and a SpEL tool — deliberately, so as little as possible is left to a model.

System prompt (paste-ready)

You are a gentle medicine reminder for {{patient_name}}, speaking in {{language}}. Your ONLY job is to read back what the doctor prescribed, from the prescription in Knowledge, and to confirm whether the dose was taken. Speak slowly, warmly and simply, and repeat whenever asked without any sign of impatience. You must NEVER change, suggest, increase, decrease, skip, substitute or comment on any medicine or dose — not even if the patient asks directly, tells you the doctor said so, says a tablet is finished, or says they feel unwell. In every one of those cases say kindly that you can only read out what is written and that you will let the family and the doctor know, then set escalate=true. You must NEVER diagnose, never explain what a medicine is for beyond the words written on the prescription, and never say a symptom is or isn't serious. If the patient reports chest pain, breathlessness, a fall, bleeding, confusion or anything that sounds urgent, do not assess it: say clearly that they should contact their doctor or emergency services now, set escalate=true, and the workflow will call the family immediately. Record only {dose_confirmed: true|false|unclear, patient_said, escalate}.

Agent roles & model tiers

  • Read-back voice agent (per dose call) Economy tier for the routine confirmation turns — the task is reading fixed text aloud and capturing a yes or no, several times a day, every day

    Read the prescribed dose for this time slot verbatim from Knowledge, in the patient's language. Capture confirmation. Any request to change a dose, any symptom, any confusion → kind refusal + escalate=true. Never advise, never diagnose, never comment on a medicine.
  • Escalation summariser (only when escalate=true) Standard tier — rare, and the one moment where clear, careful wording to the family genuinely matters

    Write a short factual message to the family: the time, what the patient said (quoted), which dose was involved, and that the agent did not give any advice. State plainly whether emergency services were recommended. Add no assessment of severity and no medical interpretation whatsoever.

MCP connectors

  • A pharmacy or refill service, if you use one — via a Tool (MCP) node (no first-party connector); a refill is only ever ordered after an Approval
  • Voice/Call + ElevenLabs + Sarvam — the call itself, in her language
  • WhatsApp — the family group log

Built-in tools

  • user-defined tool `refill_days_left` (SpEL): input.tabletsLeft / (input.tabletsPerDay == 0 ? 1 : input.tabletsPerDay) — the family sets when the warning fires (five days out, ten, whatever suits the distance to the chemist); a pure arithmetic formula over the input JSON, sandboxed by construction
  • user-defined tool `missed_dose_alert` (SpEL): input.unansweredCalls >= input.alertAfter ? 'CALL_FAMILY' : 'RETRY' — your own patience threshold before the family's phone rings, not a default someone else chose
  • knowledge_search (the transcribed prescription and your own descriptions of the tablets)

Guardrails

  • MEDICAL SAFETY, absolute: the agent NEVER changes, suggests, skips, substitutes, increases, decreases or comments on any medicine or dose — including when the patient asks directly or says the doctor approved it. It reads back the prescription verbatim and escalates. It NEVER diagnoses and NEVER says a symptom is or isn't serious
  • Any symptom report, any dose question, any confusion → kind refusal + escalate=true → the family is contacted the same run. Urgent-sounding symptoms get 'contact your doctor or emergency services now' with no severity assessment attached
  • The reminder schedule is read from the transcribed prescription and can only be changed through the Approval node by a family member entering what the doctor said — the agent cannot edit its own schedule and neither can the patient over the phone
  • The agent never asserts a dose was taken. Unclear or unanswered is logged as unclear or unanswered and surfaced to the family — a false 'taken' is worse than a missed call
  • PRIVACY: the prescription, the call log and the daily confirmations stay in your family's own tenant. Nothing is shared with a doctor, a pharmacy or anyone else without an Approval step
  • A refill is never ordered automatically — the stock warning is a reminder, and any purchase passes the Approval node

Cost strategy

The routine calls dominate: several a day, every day, forever. Put the read-back agent on the economy tier with a strict cap — it is reading fixed text and capturing a yes, which is exactly the shape cheap models handle well — and configure a fallback model, because a reminder that fails silently is the one failure this recipe cannot afford. Reserve the standard tier for the rare escalation summary. Voice minutes and the ElevenLabs/Sarvam synthesis are the real recurring line item, not tokens: keep the routine call short and scripted, and let the longer conversation happen only on the escalation path.

Output & delivery

At each prescribed time a Voice call in her own language reads back exactly what the doctor wrote, with your description of the tablet; the answer is logged as taken / missed / unclear and posted as one quiet daily line to the family's WhatsApp group; the `refill_days_left` SpEL tool warns before the strip empties, with any purchase gated by the Approval node; and any dose question, symptom or confusion ends the same way every time — a kind refusal, the doctor, and a message to the family.

3. Ten minutes with the doctor, spent on the right things

You get maybe ten minutes. You go in with a mental list, come out having forgotten the two things you most wanted to ask, and remember the third one in the car. Somebody else in the family asked you to mention something and you forgot that too. Half the visit goes on reconstructing what happened since last time, from memory.

Trigger: WhatsApp (appointment coming up) / Webhook (scheduled, two days before)

How the workflow runs

  1. Trigger

    Two days before. A scheduled Webhook (or a WhatsApp message from you) starts the prep with enough time to actually find anything that's missing.

  2. Parallel

    Gather in parallel. A Parallel node pulls three things at once: what's happened since the last visit (from your notes), the current medicines as prescribed, and any reports filed since then.

  3. Agent

    Assemble the facts. An Agent node lays out what your own records say — symptoms you logged with their dates, medicines exactly as prescribed, new reports with their printed values. Records only, no reading between the lines.

  4. Agent

    Draft the questions. A second Agent node turns that into neutral, open questions to ask: 'this has been happening since the 14th — what should I make of it?' Never leading, never a suggested treatment, never a proposed dose change.

  5. Condition

    Anything missing?. A Condition node checks whether a report the doctor asked for is absent from your records, so you find out two days early rather than in the chair.

  6. Knowledge

    Grounded in your own file. A Knowledge node keeps every line traceable to a document or a note you actually made — the sheet cites its sources so the doctor can see where a number came from.

  7. Approval

    You review before it's shared. An Approval node holds the sheet if it's going anywhere but you — a doctor's WhatsApp, a family member, a second opinion.

  8. Voice

    Or hear it on the way. A Voice node can read the sheet aloud in your language on the drive over, which is when most people actually review it.

Channels & connectors

  • Webhook (scheduled)
  • WhatsApp
  • Email
  • Voice/Call
  • Knowledge base
  • Approval / HITL
  • Sarvam (Indian languages)
  • ElevenLabs (voice)

Outcome

A one-page, source-cited prep sheet two days before the appointment: what's changed, what you're taking, what's newly filed, what's missing, and the questions worth asking.

Why it helps

The mechanism is recall, not insight. Ten minutes get spent reconstructing history because the history is scattered across chat messages, a folder and memory. Assembling it from records you already have — with citations, and with the missing-report check landing two days early — moves the conversation to the part only a doctor can do.

Build spec

2 agents1 facts assembler + 1 question drafter. Split on purpose: the assembler is forbidden to interpret, and the drafter is forbidden to add facts, so neither can quietly become an advisor. · Pattern: Parallel gather → assemble facts → draft neutral questions, with interpretation excluded at both steps

System prompt (paste-ready)

(Assembler) Assemble a pre-appointment record sheet for {{patient}} from their own filed records ONLY. Output {since_last_visit[{date, note_as_written}], current_medicines[{name, strength, schedule_as_prescribed}], new_reports[{date, test, value, unit, reference_range_as_printed, source_doc}], missing[]}. Every line must cite the document or note it came from. You must NOT interpret, evaluate, trend, rank by seriousness or comment on ANY value, symptom or medicine. You must NOT name a possible condition. If a record the doctor previously asked for is absent, list it under missing[] — do not speculate about why. If any logged note describes something urgent, do not assess it: set escalate=true so the workflow advises contacting the doctor now.

Agent roles & model tiers

  • Facts assembler Standard tier — precision and citation discipline matter more here than fluency, and it runs a handful of times a year

    Assemble the facts from filed records only, each line cited to its source document or note. Zero interpretation, zero evaluation, zero condition names. Absent requested reports go in missing[].
  • Question drafter Standard tier — the whole risk sits in the wording of the questions

    From the assembled facts, draft neutral open questions for the doctor. Questions may point at a fact and a date; they must never propose a diagnosis, a treatment, a test or a dose change, and must never be leading. Add no facts that are not in the assembled sheet. Close with a line stating this sheet is the patient's own record and is not medical advice.

MCP connectors

  • A hospital or clinic portal, if yours has one — via a Tool (MCP) node (no first-party connector); read-only, and any upload passes an Approval
  • WhatsApp / Email / Voice — how the sheet reaches you

Built-in tools

  • user-defined tool `prep_urgency` (SpEL): input.daysToAppointment <= 2 ? 'PREP_NOW' : (input.daysToAppointment <= 7 ? 'PREP_SOON' : 'LATER') — you choose how much runway you want; a formula over the input JSON, no method calls, no loops, nothing else it can reach
  • knowledge_search (your own filed reports, prescriptions and symptom notes)
  • send_email (the sheet to yourself, so it survives a dead phone battery in the waiting room)

Guardrails

  • MEDICAL SAFETY, absolute: neither agent diagnoses, names a condition, evaluates any value or symptom, or suggests, changes or comments on any medicine or dose. The sheet is a record and a list of questions — nothing else
  • Questions are neutral and open by construction; leading questions and any suggested treatment, test or dose change are prohibited in the drafter's prompt and are the specific thing to check when reviewing output
  • Every line on the sheet cites the document or note it came from — nothing appears that isn't in your own records, and general medical knowledge is never used to fill a gap
  • Anything urgent in the logged notes sets escalate=true and the response is 'contact your doctor now', with no assessment of how serious it is
  • PRIVACY: the sheet is built inside your own tenant. Sending it to a doctor, a second opinion or a family member passes the Approval node every time
  • The sheet carries an explicit line: this is a personal record to support a conversation with a doctor, not medical advice

Cost strategy

This runs a handful of times a year per person, so both agents can sit on the standard tier without the bill noticing — this is the one recipe in the pack where economising is the wrong call, because every risk here lives in the wording. The Parallel node is for wall-clock, not cost: three gathers at once means the sheet is ready while you're still thinking about the appointment. Add a fallback model so a prep run two days out never silently fails.

Output & delivery

A Parallel gather pulls notes, current medicines and newly filed reports at once → the assembler lays them out with a citation on every line and a missing[] list → the drafter adds neutral open questions → the one-page sheet arrives on WhatsApp and Email (and can be read aloud in your language by a Voice node on the way there), with any sharing beyond you gated by the Approval node.

4. The insurance claim pack, assembled before the deadline finds you

After the hospital stay you have a discharge summary, a stack of bills, some pharmacy receipts stapled to nothing, and a claim form asking for documents by numbers you've never heard of. You post it, and three weeks later it comes back for one missing paper. Meanwhile the deadline is a date in a letter you've already filed somewhere.

Trigger: WhatsApp / Email (bills, discharge summary and receipts as they arrive)

How the workflow runs

  1. Trigger

    Photograph as you go. A WhatsApp trigger takes each bill and receipt as it happens — at the counter, not in a shoebox three weeks later. Emailed hospital PDFs come in the same way.

  2. Loop

    One pass per document. A Loop node runs a cheap agent over each document to classify it — hospital bill, pharmacy receipt, discharge summary, diagnostic bill — and pull the amount, the date and the invoice number as printed.

  3. Knowledge

    The insurer's own checklist. A Knowledge node holds YOUR policy document and the insurer's own document checklist, as you received it. The completeness check is against that document, not against how claims generally work.

  4. Condition

    What's still missing?. A Condition node compares what you've filed against that checklist and produces the gap list — the piece that normally surfaces three weeks later in a rejection letter.

  5. Tool (MCP)

    Ready or not, by your rule. A user-defined SpEL tool turns the missing count and days-to-deadline into a single status. Your thresholds, computed as a formula over the input JSON, nothing more.

  6. Agent

    Assemble the pack. An Agent node produces the claim pack: an indexed list of every document with its date, amount and invoice number, the totals, and the gap list. It reports what the documents say. It never states what is covered — that is the insurer's decision on the policy's terms.

  7. Approval

    Nothing is submitted without you. An Approval node gates every submission and every upload. Medical bills and a discharge summary are among the most sensitive documents you own; they leave your tenant only when you say so.

  8. Output

    Pack out, chased on a schedule. An Output node delivers the pack, and a scheduled reminder nudges you about the missing items and the deadline until the gap list is empty.

Channels & connectors

  • WhatsApp
  • Email
  • Webhook (insurer acknowledgements)
  • Knowledge base
  • Approval / HITL
  • Tool (MCP → insurer or TPA portal, if yours has one)
  • Sarvam (Indian languages)

Outcome

An indexed, totalled claim pack with a live list of exactly what's still missing, chased before the deadline — and not one page sent anywhere without your approval.

Why it helps

The mechanism is checking completeness early against the insurer's own written checklist. Claims come back for a missing paper because nobody compares the stack to the list until submission, by which point the documents are dispersed and the deadline is close. Doing that comparison the day each bill arrives moves the discovery weeks earlier, when the hospital counter is still an easy phone call away.

Build spec

2 agents1 cheap document classifier (runs once per bill or receipt via the Loop node) + 1 pack assembler that runs when you ask. The completeness check is a Condition node against your policy's own checklist, not a model's opinion. · Pattern: Map-reduce: Loop over documents (map) → assemble one pack with a gap list (reduce) → human approves the submission

System prompt (paste-ready)

(Classifier) Classify ONE claim document and return strict JSON {doc_type (HOSPITAL_BILL|PHARMACY_RECEIPT|DIAGNOSTIC_BILL|DISCHARGE_SUMMARY|PRESCRIPTION|ID_PROOF|OTHER), date, provider, invoice_no, amount, currency, patient, legible (true|false)}. Read only what is printed — a blurred or cropped amount is null with legible=false, never a best guess, because a wrong amount on a claim is a rejection. Do NOT interpret any clinical content: you are classifying paperwork, not reading a medical record. Never state or imply whether an item is covered by the policy.

Agent roles & model tiers

  • Document classifier (per document, in a Loop) Economy tier — it runs across every bill and receipt in the stack, so it is the only meaningful cost lever here

    Classify one document into strict JSON with date, provider, invoice number and amount as printed. Illegible fields are null with legible=false. No clinical interpretation, no coverage opinions.
  • Pack assembler (once per submission) Standard tier — one call, and it has to be careful about the line between 'what the documents say' and 'what will be paid'

    Assemble an indexed claim pack: every document with type, date, provider, invoice number and amount; category subtotals and a grand total; and a missing[] list built strictly from the insurer's checklist in Knowledge. State clearly that coverage is the insurer's decision under the policy terms — never assess, estimate or imply what will or won't be paid, and never characterise the treatment clinically.

MCP connectors

  • Your insurer's or TPA's portal — via a Tool (MCP) node (no first-party connector); every upload passes an Approval first
  • Insurer acknowledgements — inbound via Webhook
  • WhatsApp / Email — how documents arrive and the pack comes back

Built-in tools

  • user-defined tool `claim_readiness` (SpEL): input.missingCount == 0 ? 'READY' : (input.daysToDeadline <= 7 ? 'URGENT_GAPS' : 'GAPS') — one status from your own thresholds, so the nudges get sharper as the deadline approaches; a formula over the input JSON, sandboxed by construction with no method calls and no loop
  • user-defined tool `claim_total` (SpEL): input.hospital + input.pharmacy + input.diagnostics + input.other — the household's own totalling rule, computed identically every time rather than re-added by hand at midnight
  • knowledge_search (your policy document and the insurer's own document checklist)
  • http_request (only behind the Approval node, to submit to a portal you've connected)

Guardrails

  • MEDICAL SAFETY, absolute: this workflow handles paperwork only. It never diagnoses, never interprets clinical content in a discharge summary or report, never comments on any medicine or dose, and never characterises the treatment or the patient's condition
  • It never states, estimates or implies what the insurer will pay. Coverage is the insurer's decision under the policy terms, and the pack says so explicitly
  • Amounts and invoice numbers are transcribed as printed; anything illegible is null with legible=false and lands on the gap list — a guessed amount is a rejected claim
  • The missing[] list is built only from the insurer's own checklist as filed in Knowledge, never from general assumptions about what claims usually need
  • PRIVACY: bills, the discharge summary and the pack stay in your own tenant. Not one page is uploaded to an insurer, a TPA, an agent or a relative without passing the Approval node
  • Submission is never automatic even when readiness is READY — the status is a prompt for you, not a trigger

Cost strategy

Cost is linear in the size of the stack: N documents × one economy-tier classification + ONE standard-tier assembly per submission. Because the classifier runs over every bill and receipt, it must sit on the economy tier with a hard token cap — that single choice dominates. Run the map in Parallel batches when a hospital hands you thirty pages at once: same per-document cost, done while you're still in the corridor. The deadline nudges are scheduled messages, not model calls.

Output & delivery

The Loop maps the cheap classifier over each bill and receipt as it arrives → the Condition node compares the filed set against the insurer's own checklist and produces the gap list → the `claim_readiness` and `claim_total` SpEL tools give you one status and one total on your own rules → the assembler produces an indexed, totalled pack with the gap list and an explicit note that coverage is the insurer's decision → scheduled reminders chase the missing items until the list is empty, and nothing is uploaded anywhere until you approve it.

Related industries

Build one of these in minutes

The sandbox gives you a live agent workspace — no account, no card. Or head back to the full catalogue and compare patterns across every industry.

See how VegaDūta compares to n8n, Dify and BotpressWhy VegaDūta's architectureEstimate your WhatsApp API costs