System architecture

These are the components no vendor has. They are the moat.

• HL7 v2 ADT listener

  Pilot integration
  Legacy ADT is the most reliable real-time signal. We listen via Mirth Connect-style integration engine inside our infra.
• Patient portal events

  Live in prototype
  We own the portal end-to-end; events stream to the engine in <500ms via SSE.
• Brain tick (scheduled detectors)

  Live in prototype
  Domain-specific signal engine. Scheduled re-evaluation runs deterministic detectors; AI generates narrative on detail view only.
• Six-Dimension Readiness Engine

  Live in prototype
  Core IP. No vendor has this. Recomputes on every relevant event; emits pillar deltas to the routing engine.
• PaCHE barrier ontology + FSM

  Live in prototype
  The substrate of the platform. Every barrier classified, owned, state-tracked, audited.
• Brain detectors

  Live in prototype
  Severity is computed deterministically. AI generates narrative only on demand via runAgent (never decides severity).
• Resource matcher (graph)

  Live in prototype
  Deterministic ranking on top of curated Resource Hub. Where AI assists, it only generates rationale text.
• Task orchestrator

  Live in prototype
  Cross-role coordination is the moat. No off-the-shelf workflow tool understands hospital roles + state semantics.
• Audit spine (AgentInference + Submission)

  Live in prototype
  Legally-load-bearing. Answers payer dispute, regulator audit, plaintiff lawyer — 'what did the AI propose, who approved, what was sent.'
• Notification bus

  Live in prototype
  Custom routing logic per role / urgency / channel. Wraps Twilio for SMS, SendGrid for email.
• CM Console

  Live in prototype
  Hero surface. Built on Next.js + Tailwind; deep integration with the engine.
• MD Widget (Epic Sidebar)

  Pilot integration
  SMART-on-FHIR launched inside Epic. Surfaces the engine where MDs work.
• Patient + Family Portal

  Live in prototype
  No vendor owns this surface for discharge specifically.
• Admin / Throughput dashboard

  Live in prototype
  Required for CFO + hospital ops buyer. Built on Recharts; reads from audit spine + engine state.

Commodity infrastructure. We integrate, we don't rebuild.

• Epic FHIR R4

  Pilot integration
  EHR connectivity is commodity infrastructure. Building our own connector is an 18-month rabbit hole. We integrate via Epic's FHIR R4 API + SMART-on-FHIR launch.
• Redox (multi-EHR connector)

  Planned
  Multi-EHR support without per-vendor engineering. Redox handles auth, mapping, and rate-limits.
• Eligibility (X12 270/271)

  Pilot integration
  EDI clearinghouse is commodity. Availity is the largest; Change Healthcare and Waystar are alternatives.
• Surescripts (formulary + benefit)

  Pilot integration
  De-facto standard for ePrescribing infrastructure. We use the read side for formulary + the write side for ePrescriptions.
• Naviguide capacity feed

  Pilot integration
  Post-acute capacity is the hardest signal to get without a vendor. Naviguide / WellSky CarePort / Aidin all aggregate it; pick by hospital preference.
• DME partner capacity (Lincare, Apria, Inogen)

  Planned
  Direct vendor APIs where available; Parachute Health for aggregation. Voice agent fallback for vendors without APIs.
• ModivCare NEMT availability

  Pilot integration
  Largest CA Medicaid NEMT broker. Direct API integration.
• Voalte ack stream

  Planned
  Most hospitals already on Vocera/Voalte/Halo for nursing comms. We listen to their event stream rather than asking them to switch.
• Event bus (Inngest workflows)

  Pilot integration
  Durable execution + retries + observability without building our own. Inngest is the right primitive for this shape of work.
• EHR writeback

  Pilot integration
  Closes the loop. Every CM action that should live in the EHR is written via FHIR R4.
• CoverMyMeds (PBM prior auth)

  Pilot integration
  CoverMyMeds is the de-facto standard with PBM connections (CVS Caremark, Express Scripts, OptumRx). We automate the drafting; they own the pipe to the PBM.
• Availity (medical PA + EDI)

  Pilot integration
  Largest provider portal + payer connectivity in US.
• Naviguide e-referral

  Pilot integration
  We don't replace the SNF e-referral vendor — we automate the packet drafting and surface response in the CM workflow.
• Parachute Health (DME orders)

  Planned
  Parachute aggregates DME vendors; we send one order, they fan out.
• ModivCare NEMT booking

  Pilot integration
  Direct broker booking.
• Twilio + Vapi/Retell (voice agents)

  Pilot integration
  Twilio for telephony infra; Vapi/Retell for the voice-AI runtime. We compose prompts via runAgent.
• Documo (e-fax fallback)

  Pilot integration
  Unfortunately required in healthcare. Documo is HIPAA-safe.
• Voalte-style task feed

  Planned
  We push tasks into Vocera/Voalte rather than asking nurses to switch apps.

Foundational platforms we leverage (LLM runtime, durable workflows).

• AI agent layer (Claude via runAgent)

  Live in prototype
  Built on Anthropic Claude (Sonnet 4.6 + Haiku 4.5). Every call routed through runAgent — writes AgentInference row with cost, latency, prompt hash, approval triple.