HERALD: Hospital Emergency Room Agentic Live Digital-twin

HERALD is an autonomous digital twin of a hospital emergency room where every patient, nurse, doctor, and piece of equipment is a live AI agent.

Comment

Inspiration

  • ERs run on fragmented whiteboards, pagers, and tribal knowledge — there's no live, queryable model of who's where and what's free right now.
  • We wanted to see if every physical entity in a hospital — patient, nurse, doctor, bed, oxygen unit — could be its own autonomous agent reasoning in real time.
  • The promise of a "digital twin" you can just talk to ("admit MRN-0005", "discharge MRN-0002") felt like the natural interface for high-pressure clinical ops.

What it does

  • Models an entire emergency room as cooperating uAgents in one Bureau, reachable from ASI:One chat, with a live admin dashboard mirroring every state change.
  • Runs MRN-driven intake (triage → propose bed/nurse/doctor → admit) and discharge (propose sign-off → mark discharged → free resources on resolve), all with human-in-the-loop confirmation.
  • Detects critical events like low-oxygen alerts, auto-dispatches the nearest free nurse, and records a structured incident trace of every action taken.

How we built it

  • Python 3.11 + uagents: a public Orchestrator agent (mailbox + Chat Protocol) plus private entity agents, all sharing state behind a StorageInterface (in-memory default, Redis swap).
  • Event-registry pattern (plan → confirm → resolve) so every event proposes read-only first and only mutates state after admin approval — keeping the demo deterministic.
  • A FastAPI + vanilla-JS dashboard with interactive proposal cards for real-time, human-in-the-loop control of the ER floor.

Challenges we ran into

  • Getting a mailbox-backed public agent to coexist with private agents in a single Bureau — we de-risked it with a spike before committing to the architecture.
  • Premature state mutation: proposals were decrementing availability before confirmation, so we refactored intake/discharge to be fully read-only until commit.
  • A subtle data bug where seeded patients had no MRN made them undischargeable — a reminder that MRN is the join key across every flow.

Accomplishments that we're proud of

  • A genuinely conversational ER: you run the whole floor — admit, assign, discharge, resolve — from plain ASI:One chat, with the dashboard updating live.
  • Clean separation of intent → plan → commit → resolve, giving deterministic demos and idempotent, testable handlers backed by EARS specs.
  • End-to-end autonomy on the oxygen event: drop detected, nearest free nurse dispatched, and the equipment swap applied automatically.

What we learned

  • Async, message-passing agents force you to think in terms of state machines and idempotency, not request/response — every trigger must be safe to fire twice.
  • Deferring all writes until confirmation makes a system both safer and far easier to demo under pressure.
  • Spec-driven development (README → LLD → EARS → tests → code) kept a multi-person build from drifting into mismatched message names and keys.

What's next for HERALD: Hospital Emergency Room Agentic Live Digital-twin

  • Swap the in-memory store for Redis-backed persistence and multi-room scaling, with real-time vitals streaming from monitoring devices.
  • Smarter triage and assignment via LLM reasoning over full EHR history, plus predictive alerts (deterioration, bed-capacity, staffing gaps).
  • EHR/FHIR integration and audit-grade compliance so HERALD can move from synthetic demo to a real clinical pilot.

Built With

Share this project:

Updates