Atlas

About the Project

What inspired us

Emergency departments are chaotic, but not because care is impossible. It is because information does not reach the right person at the right time. Doctors spend nearly half their shift on documentation, while patients wait on coordination gaps.

We were also frustrated with how opaque most AI systems feel. If a model makes a claim but cannot explain it, trust breaks. That led to our core idea: every output should be inspectable and correctable.

Finally, privacy pushed our architecture. Sensitive patient data should not leave the hospital, and personal records should stay with the patient. That principle shaped everything we built.

What we built

ATLAS is an on-prem, multi-agent system for emergency departments. It runs locally and coordinates five agents:

Scribe writes clinical notes from encounter audio
Quartermaster manages coordination and predicts delays
Advocate prepares prior authorizations during the visit
Conductor generates handoffs and discharge plans
Reality Check audits all outputs for errors

The key feature is “Show Our Work”. Every claim is backed by evidence and a reasoning chain that doctors can inspect and correct. If a premise is wrong, the system recomputes instantly.

We also built:

Pulse: a cloud-based medical literature companion with zero patient data
Patient Companion app: an on-device app that summarizes visits and answers insurance questions using only the patient’s own documents

How we built it

We designed ATLAS as a local-first system running on a single machine with shared memory for multiple models.

A central orchestrator routes events between agents
Every output must include evidence and a reasoning chain
If an agent fails to provide evidence, it is rejected and rerun

We used larger models for reasoning-heavy tasks and smaller ones for fast updates. Speech-to-text powers live documentation, while embeddings support retrieval.

On the mobile side, we built a Kotlin app with fully on-device models. For retrieval, we used lightweight cosine similarity over small vector sets instead of heavy infrastructure.

We also enforced a strict architectural boundary: [ \text{PHI (ATLAS)} \cap \text{Pulse} = \emptyset ] No patient data ever crosses into the cloud system.

What we learned

Transparency matters more than raw model power
Constraints like running on-device lead to better system design
Multi-agent systems are only valuable if agents truly interact
Good storytelling is as important as good engineering

Challenges we faced

Scope: building multiple agents in limited time required strict prioritization
Latency: responses needed to feel real-time, especially after corrections
Speech input: live transcription is unreliable, so we built fallbacks
Accuracy: enforcing evidence-backed outputs required system-level constraints
On-device limits: mobile performance and memory required careful tradeoffs